From 3119a7ead9613fa2daac037cc2626be1877975f7 Mon Sep 17 00:00:00 2001 From: KoroLion Date: Tue, 15 Jun 2021 12:25:32 +0300 Subject: [PATCH] Initial commit --- .gitignore | 2 + Makefile | 2 + README.md | 7 + lib/sqlite3.h | 12264 ++++++++++++++++++++++++++++++++++++++++++++++++ main.cpp | 127 + sqlite3.dll | Bin 0 -> 1071715 bytes 6 files changed, 12402 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 lib/sqlite3.h create mode 100644 main.cpp create mode 100644 sqlite3.dll diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6958ea4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.sqlite +*.exe \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..7b5fcc7 --- /dev/null +++ b/Makefile @@ -0,0 +1,2 @@ +main.exe: main.cpp + g++ -I./lib -L. -lsqlite3 main.cpp -o main.exe diff --git a/README.md b/README.md new file mode 100644 index 0000000..927546a --- /dev/null +++ b/README.md @@ -0,0 +1,7 @@ +### Compile: +* make main.exe + +### Useful links +* https://inloop.github.io/sqlite-viewer/ +* https://www.tutorialspoint.com/sqlite/sqlite_c_cpp.htm +* https://www.sqlite.org/cintro.html diff --git a/lib/sqlite3.h b/lib/sqlite3.h new file mode 100644 index 0000000..19ee767 --- /dev/null +++ b/lib/sqlite3.h @@ -0,0 +1,12264 @@ +/* +** 2001-09-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 supposed 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 /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +extern "C" { +#endif + + +/* +** Provide the ability to override linkage features of the interface. +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif +#ifndef SQLITE_API +# define SQLITE_API +#endif +#ifndef SQLITE_CDECL +# define SQLITE_CDECL +#endif +#ifndef SQLITE_APICALL +# define SQLITE_APICALL +#endif +#ifndef SQLITE_STDCALL +# define SQLITE_STDCALL SQLITE_APICALL +#endif +#ifndef SQLITE_CALLBACK +# define SQLITE_CALLBACK +#endif +#ifndef SQLITE_SYSAPI +# define SQLITE_SYSAPI +#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 supported 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] ([dateof:3.6.18]), +** SQLite source code has been stored in the +** Fossil configuration management +** system. ^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 a SHA1 +** or SHA3-256 hash of the entire source tree. If the source code has +** been edited in any way since it was last checked in, then the last +** four hexadecimal digits of the hash may be modified. +** +** See also: [sqlite3_libversion()], +** [sqlite3_libversion_number()], [sqlite3_sourceid()], +** [sqlite_version()] and [sqlite_source_id()]. +*/ +#define SQLITE_VERSION "3.35.5" +#define SQLITE_VERSION_NUMBER 3035005 +#define SQLITE_SOURCE_ID "2021-04-19 18:32:05 1b256d97b553a9611efca188a3d995a2fff712759044ba480f9a0c9e98fae886" + +/* +** 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 ensure that the application is +** compiled with matching library and header files. +** +** 
+** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
+** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
+**
)^ +** +** ^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. Except if SQLite is built +** using an edited copy of [the amalgamation], then the last four characters +** of the hash might be different from [SQLITE_SOURCE_ID].)^ +** +** 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); +#else +# define sqlite3_compileoption_used(X) 0 +# define sqlite3_compileoption_get(X) ((void*)0) +#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_SERIALIZED]. ^(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; +# ifdef SQLITE_UINT64_TYPE + typedef SQLITE_UINT64_TYPE sqlite_uint64; +# else + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +# endif +#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 +** DESTRUCTOR: sqlite3 +** +** ^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. +** +** Ideally, 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 the database connection is associated with unfinalized prepared +** statements, BLOB handlers, and/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, unclosed BLOB handlers, and/or unfinished sqlite3_backups, +** it returns [SQLITE_OK] regardless, but instead of deallocating the database +** connection immediately, it marks the database connection as an unusable +** "zombie" and makes arrangements to automatically deallocate the database +** connection after all prepared statements are finalized, all BLOB handles +** are closed, and all backups have 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. +** +** ^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 +** METHOD: sqlite3 +** +** 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 +** 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: +** +** +*/ +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: {result code definitions} +** +** 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: [extended result code definitions] +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* Generic error */ +#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 /* Internal use only */ +#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 /* Not used */ +#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_NOTICE 27 /* Notifications from sqlite3_log() */ +#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */ +#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 result code definitions} +** +** In its default configuration, SQLite API routines return one of 30 integer +** [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 [dateof:3.3.8] +** and later) include +** support for additional result codes that provide more detailed information +** about errors. These [extended result codes] are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. Or, the extended code for +** the most recent error can be obtained using +** [sqlite3_extended_errcode()]. +*/ +#define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8)) +#define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8)) +#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8)) +#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_IOERR_MMAP (SQLITE_IOERR | (24<<8)) +#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) +#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) +#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) +#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8)) +#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8)) +#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8)) +#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8)) +#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8)) +#define SQLITE_IOERR_CORRUPTFS (SQLITE_IOERR | (33<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) +#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<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_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) +#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ +#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8)) +#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) +#define SQLITE_READONLY_CANTINIT (SQLITE_READONLY | (5<<8)) +#define SQLITE_READONLY_DIRECTORY (SQLITE_READONLY | (6<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) +#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) +#define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8)) +#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) +#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) +#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) +#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) +#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8)) +#define SQLITE_OK_SYMLINK (SQLITE_OK | (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 */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#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_SUPER_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() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ +#define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ + +/* Reserved: 0x00F00000 */ +/* Legacy compatibility: */ +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ + + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of 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(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +** flag indicates that a file cannot be deleted when open. The +** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +** read-only media and cannot be changed even by processes with +** elevated privileges. +** +** The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying +** filesystem supports doing multiple write operations atomically when those +** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and +** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. +*/ +#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 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 +#define SQLITE_IOCAP_IMMUTABLE 0x00002000 +#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000 + +/* +** CAPI3REF: File Locking Levels +** +** 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 +** +** 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(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** 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 +** +** 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 [sqlite3_vfs.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 [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.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 +** +** 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 [file control opcodes | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** 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: +** +** +** +** 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*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); + int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p); + /* Methods above are valid for version 3 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** KEYWORDS: {file control opcodes} {file control opcode} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +** +*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 +#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 +#define SQLITE_FCNTL_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 +#define SQLITE_FCNTL_MMAP_SIZE 18 +#define SQLITE_FCNTL_TRACE 19 +#define SQLITE_FCNTL_HAS_MOVED 20 +#define SQLITE_FCNTL_SYNC 21 +#define SQLITE_FCNTL_COMMIT_PHASETWO 22 +#define SQLITE_FCNTL_WIN32_SET_HANDLE 23 +#define SQLITE_FCNTL_WAL_BLOCK 24 +#define SQLITE_FCNTL_ZIPVFS 25 +#define SQLITE_FCNTL_RBU 26 +#define SQLITE_FCNTL_VFS_POINTER 27 +#define SQLITE_FCNTL_JOURNAL_POINTER 28 +#define SQLITE_FCNTL_WIN32_GET_HANDLE 29 +#define SQLITE_FCNTL_PDB 30 +#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31 +#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32 +#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33 +#define SQLITE_FCNTL_LOCK_TIMEOUT 34 +#define SQLITE_FCNTL_DATA_VERSION 35 +#define SQLITE_FCNTL_SIZE_LIMIT 36 +#define SQLITE_FCNTL_CKPT_DONE 37 +#define SQLITE_FCNTL_RESERVE_BYTES 38 +#define SQLITE_FCNTL_CKPT_START 39 + +/* deprecated names */ +#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE +#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE +#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO + + +/* +** CAPI3REF: Mutex Handle +** +** 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: Loadable Extension Thunk +** +** A pointer to the opaque sqlite3_api_routines structure is passed as +** the third parameter to entry points of [loadable extensions]. This +** structure must be typedefed in order to work around compiler warnings +** on some platforms. +*/ +typedef struct sqlite3_api_routines sqlite3_api_routines; + +/* +** CAPI3REF: OS Interface Object +** +** 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". See +** the [VFS | VFS documentation] for further information. +** +** The VFS interface is sometimes extended by adding new methods onto +** the end. Each time such an extension occurs, the iVersion field +** is incremented. The iVersion value started out as 1 in +** SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2 +** with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased +** to 3 with SQLite [version 3.7.6] on [dateof:3.7.6]. Additional fields +** may be appended to the sqlite3_vfs object and the iVersion value +** may increase again in future versions of SQLite. +** Note that due to an oversight, the structure +** of the sqlite3_vfs object changed in the transition from +** SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0] +** and yet the iVersion field was not increased. +** +** 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. +** +** [[sqlite3_vfs.xOpen]] +** ^SQLite guarantees that the zFilename parameter to xOpen +** is either a NULL pointer or string obtained +** from xFullPathname() with an optional suffix added. +** ^If a suffix is added to the zFilename parameter, it will +** consist of a single "-" character followed by no more than +** 11 alphanumeric and/or "-" characters. +** ^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 to 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: +** +** )^ +** +** 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: +** +** +** +** 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 and their journals, transient +** databases, and 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 not 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. +** +** [[sqlite3_vfs.xAccess]] +** ^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 SQLITE_ACCESS_READ +** flag is never actually used and is not implemented in the built-in +** VFSes of SQLite. The file is named by the second argument and can be a +** directory. The xAccess method returns [SQLITE_OK] on success or some +** non-zero error code if there is an I/O error or if the name of +** the file given in the second argument is illegal. If SQLITE_OK +** is returned, then non-zero or zero is written into *pResOut to indicate +** whether or not the file is accessible. +** +** ^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(), xCurrentTime(), and xCurrentTimeInt64() +** 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 as +** a floating point value. +** ^The xCurrentTimeInt64() method returns, as an integer, the Julian +** Day Number multiplied by 86400000 (the number of milliseconds in +** a 24-hour day). +** ^SQLite will use the xCurrentTimeInt64() method to get the current +** date and time if that method is available (if iVersion is 2 or +** greater and the function pointer is not NULL) and will fall back +** to xCurrentTime() if xCurrentTimeInt64() is unavailable. +** +** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +** are not used by the SQLite core. These optional interfaces are provided +** by some VFSes to facilitate testing of the VFS code. By overriding +** system calls with functions under its control, a test program can +** simulate faults and error conditions that would otherwise be difficult +** or impossible to induce. The set of system calls that can be overridden +** varies from one VFS to another, and from one version of the same VFS to the +** next. Applications that use these interfaces must be prepared for any +** or all of these interfaces to be NULL or for their behavior to change +** from one release to the next. Applications must not attempt to access +** any of these methods if the iVersion of the VFS is less than 3. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +typedef void (*sqlite3_syscall_ptr)(void); +struct sqlite3_vfs { + int iVersion; /* Structure version number (currently 3) */ + 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 *); + /* + ** The methods above are in version 1 of the sqlite_vfs object + ** definition. Those that follow are added in version 2 or later + */ + int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); + /* + ** The methods above are in versions 1 and 2 of the sqlite_vfs object. + ** Those below are for version 3 and greater. + */ + int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); + sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); + const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); + /* + ** The methods above are in versions 1 through 3 of the sqlite_vfs object. + ** New fields may be appended in future versions. The iVersion + ** value will increment whenever this happens. + */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method +** +** These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. 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 named directory is both readable and writable +** (in other words, if files can be added, removed, and renamed within +** the directory). +** The SQLITE_ACCESS_READWRITE constant is currently used only by the +** [temp_store_directory pragma], though this could change in a future +** release of SQLite. +** With SQLITE_ACCESS_READ, the xAccess method +** checks whether the file is readable. The SQLITE_ACCESS_READ constant is +** currently unused, though it might be used in a future release of +** SQLite. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ +#define SQLITE_ACCESS_READ 2 /* Unused */ + +/* +** CAPI3REF: Flags for the xShmLock VFS method +** +** These integer constants define the various locking operations +** allowed by the xShmLock method of [sqlite3_io_methods]. The +** following are the only legal combinations of flags to the +** xShmLock method: +** +** +** +** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as +** was given on the corresponding lock. +** +** The xShmLock method can transition between unlocked and SHARED or +** between unlocked and EXCLUSIVE. It cannot transition between SHARED +** and EXCLUSIVE. +*/ +#define SQLITE_SHM_UNLOCK 1 +#define SQLITE_SHM_LOCK 2 +#define SQLITE_SHM_SHARED 4 +#define SQLITE_SHM_EXCLUSIVE 8 + +/* +** CAPI3REF: Maximum xShmLock index +** +** The xShmLock method on [sqlite3_io_methods] may use values +** between 0 and this upper bound as its "offset" argument. +** The SQLite core will never attempt to acquire or release a +** lock outside of this range +*/ +#define SQLITE_SHM_NLOCK 8 + + +/* +** CAPI3REF: Initialize The SQLite Library +** +** ^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. +*/ +SQLITE_API int sqlite3_initialize(void); +SQLITE_API int sqlite3_shutdown(void); +SQLITE_API int sqlite3_os_init(void); +SQLITE_API int sqlite3_os_end(void); + +/* +** CAPI3REF: Configuring The SQLite Library +** +** 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 ensure that no other SQLite interfaces are invoked by other +** threads while sqlite3_config() is running. +** +** The sqlite3_config() interface +** may only be invoked prior to library initialization using +** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before +** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. +** 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 +** [configuration option] that determines +** what property of SQLite is to be configured. Subsequent arguments +** vary depending on the [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]. +*/ +SQLITE_API int sqlite3_config(int, ...); + +/* +** CAPI3REF: Configure database connections +** METHOD: sqlite3 +** +** 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 second argument to sqlite3_db_config(D,V,...) is the +** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code +** that indicates what aspect of the [database connection] is being configured. +** Subsequent arguments vary depending on the configuration verb. +** +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if +** the call is considered successful. +*/ +SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Memory Allocation Routines +** +** 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, xRealloc, and xFree methods must work like the +** malloc(), realloc() and free() functions from the standard C library. +** ^SQLite guarantees that the second argument to +** xRealloc is always a value returned by a prior call to xRoundup. +** +** 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. +** Every memory allocation request coming in through [sqlite3_malloc()] +** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +** that causes the corresponding memory allocation to fail. +** +** The xInit method initializes the memory allocator. For example, +** it might allocate any required mutexes or initialize internal data +** structures. The xShutdown method is invoked (indirectly) by +** [sqlite3_shutdown()] and should deallocate any resources acquired +** by xInit. The pAppData pointer is used as the only parameter to +** xInit and xShutdown. +** +** SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes +** the xInit method, so the xInit method need not be threadsafe. The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. For all other methods, SQLite +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +** it is by default) and so the methods are automatically serialized. +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +** methods must be threadsafe or else make their own arrangements for +** serialization. +** +** SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +*/ +typedef struct sqlite3_mem_methods sqlite3_mem_methods; +struct sqlite3_mem_methods { + void *(*xMalloc)(int); /* Memory allocation function */ + void (*xFree)(void*); /* Free a prior allocation */ + void *(*xRealloc)(void*,int); /* Resize an allocation */ + int (*xSize)(void*); /* Return the size of an allocation */ + int (*xRoundup)(int); /* Round up request size to allocation size */ + int (*xInit)(void*); /* Initialize the memory allocator */ + void (*xShutdown)(void*); /* Deinitialize the memory allocator */ + void *pAppData; /* Argument to xInit() and xShutdown() */ +}; + +/* +** CAPI3REF: Configuration Options +** KEYWORDS: {configuration option} +** +** These constants are the available integer configuration options that +** can be passed as the first argument to the [sqlite3_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_config()] to make sure that +** the call worked. The [sqlite3_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+** [[SQLITE_CONFIG_SINGLETHREAD]]
SQLITE_CONFIG_SINGLETHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Single-thread. In other words, it disables +** all mutexing and puts SQLite into a mode where it can only be used +** by a single thread. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to change the [threading mode] from its default +** value of Single-thread and so [sqlite3_config()] will return +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD +** configuration option.
+** +** [[SQLITE_CONFIG_MULTITHREAD]]
SQLITE_CONFIG_MULTITHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Multi-thread. In other words, it disables +** mutexing on [database connection] and [prepared statement] objects. +** The application is responsible for serializing access to +** [database connections] and [prepared statements]. But other mutexes +** are enabled so that SQLite will be safe to use in a multi-threaded +** environment as long as no two threads attempt to use the same +** [database connection] at the same time. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Multi-thread [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_MULTITHREAD configuration option.
+** +** [[SQLITE_CONFIG_SERIALIZED]]
SQLITE_CONFIG_SERIALIZED
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Serialized. In other words, this option enables +** all mutexes including the recursive +** mutexes on [database connection] and [prepared statement] objects. +** In this mode (which is the default when SQLite is compiled with +** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access +** to [database connections] and [prepared statements] so that the +** application is free to use the same [database connection] or the +** same [prepared statement] in different threads at the same time. +** ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Serialized [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_SERIALIZED configuration option.
+** +** [[SQLITE_CONFIG_MALLOC]]
SQLITE_CONFIG_MALLOC
+**
^(The SQLITE_CONFIG_MALLOC option takes a single argument which is +** a pointer to an instance of the [sqlite3_mem_methods] structure. +** The argument specifies +** alternative low-level memory allocation routines to be used in place of +** the memory allocation routines built into SQLite.)^ ^SQLite makes +** its own private copy of the content of the [sqlite3_mem_methods] structure +** before the [sqlite3_config()] call returns.
+** +** [[SQLITE_CONFIG_GETMALLOC]]
SQLITE_CONFIG_GETMALLOC
+**
^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which +** is a pointer to an instance of the [sqlite3_mem_methods] structure. +** The [sqlite3_mem_methods] +** structure is filled with the currently defined memory allocation routines.)^ +** This option can be used to overload the default memory allocation +** routines with a wrapper that simulations memory allocation failure or +** tracks memory usage, for example.
+** +** [[SQLITE_CONFIG_SMALL_MALLOC]]
SQLITE_CONFIG_SMALL_MALLOC
+**
^The SQLITE_CONFIG_SMALL_MALLOC option takes single argument of +** type int, interpreted as a boolean, which if true provides a hint to +** SQLite that it should avoid large memory allocations if possible. +** SQLite will run faster if it is free to make large memory allocations, +** but some application might prefer to run slower in exchange for +** guarantees about memory fragmentation that are possible if large +** allocations are avoided. This hint is normally off. +**
+** +** [[SQLITE_CONFIG_MEMSTATUS]]
SQLITE_CONFIG_MEMSTATUS
+**
^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int, +** interpreted as a boolean, which enables or disables the collection of +** memory allocation statistics. ^(When memory allocation statistics are +** disabled, the following SQLite interfaces become non-operational: +**
    +**
  • [sqlite3_hard_heap_limit64()] +**
  • [sqlite3_memory_used()] +**
  • [sqlite3_memory_highwater()] +**
  • [sqlite3_soft_heap_limit64()] +**
  • [sqlite3_status64()] +**
)^ +** ^Memory allocation statistics are enabled by default unless SQLite is +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory +** allocation statistics are disabled by default. +**
+** +** [[SQLITE_CONFIG_SCRATCH]]
SQLITE_CONFIG_SCRATCH
+**
The SQLITE_CONFIG_SCRATCH option is no longer used. +**
+** +** [[SQLITE_CONFIG_PAGECACHE]]
SQLITE_CONFIG_PAGECACHE
+**
^The SQLITE_CONFIG_PAGECACHE option specifies a memory pool +** that SQLite can use for the database page cache with the default page +** cache implementation. +** This configuration option is a no-op if an application-defined page +** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2]. +** ^There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to +** 8-byte aligned memory (pMem), the size of each page cache line (sz), +** and the number of cache lines (N). +** The sz argument should be the size of the largest database page +** (a power of two between 512 and 65536) plus some extra bytes for each +** page header. ^The number of extra bytes needed by the page header +** can be determined using [SQLITE_CONFIG_PCACHE_HDRSZ]. +** ^It is harmless, apart from the wasted memory, +** for the sz parameter to be larger than necessary. The pMem +** argument must be either a NULL pointer or a pointer to an 8-byte +** aligned block of memory of at least sz*N bytes, otherwise +** subsequent behavior is undefined. +** ^When pMem is not NULL, SQLite will strive to use the memory provided +** to satisfy page cache needs, falling back to [sqlite3_malloc()] if +** a page cache line is larger than sz bytes or if all of the pMem buffer +** is exhausted. +** ^If pMem is NULL and N is non-zero, then each database connection +** does an initial bulk allocation for page cache memory +** from [sqlite3_malloc()] sufficient for N cache lines if N is positive or +** of -1024*N bytes if N is negative, . ^If additional +** page cache memory is needed beyond what is provided by the initial +** allocation, then SQLite goes to [sqlite3_malloc()] separately for each +** additional cache line.
+** +** [[SQLITE_CONFIG_HEAP]]
SQLITE_CONFIG_HEAP
+**
^The SQLITE_CONFIG_HEAP option specifies a static memory buffer +** that SQLite will use for all of its dynamic memory allocation needs +** beyond those provided for by [SQLITE_CONFIG_PAGECACHE]. +** ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled +** with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns +** [SQLITE_ERROR] if invoked otherwise. +** ^There are three arguments to SQLITE_CONFIG_HEAP: +** An 8-byte aligned pointer to the memory, +** the number of bytes in the memory buffer, and the minimum allocation size. +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts +** to using its default memory allocator (the system malloc() implementation), +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the +** memory pointer is not NULL then the alternative memory +** allocator is engaged to handle all of SQLites memory allocation needs. +** The first pointer (the memory pointer) must be aligned to an 8-byte +** boundary or subsequent behavior of SQLite will be undefined. +** The minimum allocation size is capped at 2**12. Reasonable values +** for the minimum allocation size are 2**5 through 2**8.
+** +** [[SQLITE_CONFIG_MUTEX]]
SQLITE_CONFIG_MUTEX
+**
^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a +** pointer to an instance of the [sqlite3_mutex_methods] structure. +** The argument specifies alternative low-level mutex routines to be used +** in place the mutex routines built into SQLite.)^ ^SQLite makes a copy of +** the content of the [sqlite3_mutex_methods] structure before the call to +** [sqlite3_config()] returns. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_GETMUTEX]]
SQLITE_CONFIG_GETMUTEX
+**
^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which +** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The +** [sqlite3_mutex_methods] +** structure is filled with the currently defined mutex routines.)^ +** This option can be used to overload the default mutex allocation +** routines with a wrapper used to track mutex usage for performance +** profiling or testing, for example. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_LOOKASIDE]]
SQLITE_CONFIG_LOOKASIDE
+**
^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine +** the default size of lookaside memory on each [database connection]. +** The first argument is the +** size of each lookaside buffer slot and the second is the number of +** slots allocated to each database connection.)^ ^(SQLITE_CONFIG_LOOKASIDE +** sets the default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] +** option to [sqlite3_db_config()] can be used to change the lookaside +** configuration on individual connections.)^
+** +** [[SQLITE_CONFIG_PCACHE2]]
SQLITE_CONFIG_PCACHE2
+**
^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is +** a pointer to an [sqlite3_pcache_methods2] object. This object specifies +** the interface to a custom page cache implementation.)^ +** ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.
+** +** [[SQLITE_CONFIG_GETPCACHE2]]
SQLITE_CONFIG_GETPCACHE2
+**
^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which +** is a pointer to an [sqlite3_pcache_methods2] object. SQLite copies of +** the current page cache implementation into that object.)^
+** +** [[SQLITE_CONFIG_LOG]]
SQLITE_CONFIG_LOG
+**
The SQLITE_CONFIG_LOG option is used to configure the SQLite +** global [error log]. +** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a +** function with a call signature of void(*)(void*,int,const char*), +** and a pointer to void. ^If the function pointer is not NULL, it is +** invoked by [sqlite3_log()] to process each logging event. ^If the +** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. +** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is +** passed through as the first parameter to the application-defined logger +** function whenever that function is invoked. ^The second parameter to +** the logger function is a copy of the first parameter to the corresponding +** [sqlite3_log()] call and is intended to be a [result code] or an +** [extended result code]. ^The third parameter passed to the logger is +** log message after formatting via [sqlite3_snprintf()]. +** The SQLite logging interface is not reentrant; the logger function +** supplied by the application must not invoke any SQLite interface. +** In a multi-threaded application, the application-defined logger +** function must be threadsafe.
+** +** [[SQLITE_CONFIG_URI]]
SQLITE_CONFIG_URI +**
^(The SQLITE_CONFIG_URI option takes a single argument of type int. +** If non-zero, then URI handling is globally enabled. If the parameter is zero, +** then URI handling is globally disabled.)^ ^If URI handling is globally +** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()], +** [sqlite3_open16()] or +** specified as part of [ATTACH] commands are interpreted as URIs, regardless +** of whether or not the [SQLITE_OPEN_URI] flag is set when the database +** connection is opened. ^If it is globally disabled, filenames are +** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the +** database connection is opened. ^(By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** [SQLITE_USE_URI] symbol defined.)^ +** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
SQLITE_CONFIG_COVERING_INDEX_SCAN +**
^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer +** argument which is interpreted as a boolean in order to enable or disable +** the use of covering indices for full table scans in the query optimizer. +** ^The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** +** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] +**
SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE +**
These options are obsolete and should not be used by new code. +** They are retained for backwards compatibility but are now no-ops. +**
+** +** [[SQLITE_CONFIG_SQLLOG]] +**
SQLITE_CONFIG_SQLLOG +**
This option is only available if sqlite is compiled with the +** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. An example of using this +** configuration option can be seen in the "test_sqllog.c" source file in +** the canonical SQLite source tree.
+** +** [[SQLITE_CONFIG_MMAP_SIZE]] +**
SQLITE_CONFIG_MMAP_SIZE +**
^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values +** that are the default mmap size limit (the default setting for +** [PRAGMA mmap_size]) and the maximum allowed mmap size limit. +** ^The default setting can be overridden by each database connection using +** either the [PRAGMA mmap_size] command, or by using the +** [SQLITE_FCNTL_MMAP_SIZE] file control. ^(The maximum allowed mmap size +** will be silently truncated if necessary so that it does not exceed the +** compile-time maximum mmap size set by the +** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^ +** ^If either argument to this option is negative, then that argument is +** changed to its compile-time default. +** +** [[SQLITE_CONFIG_WIN32_HEAPSIZE]] +**
SQLITE_CONFIG_WIN32_HEAPSIZE +**
^The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is +** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro +** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value +** that specifies the maximum size of the created heap. +** +** [[SQLITE_CONFIG_PCACHE_HDRSZ]] +**
SQLITE_CONFIG_PCACHE_HDRSZ +**
^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which +** is a pointer to an integer and writes into that integer the number of extra +** bytes per page required for each page in [SQLITE_CONFIG_PAGECACHE]. +** The amount of extra space required can change depending on the compiler, +** target platform, and SQLite version. +** +** [[SQLITE_CONFIG_PMASZ]] +**
SQLITE_CONFIG_PMASZ +**
^The SQLITE_CONFIG_PMASZ option takes a single parameter which +** is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded +** sorter to that integer. The default minimum PMA Size is set by the +** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched +** to help with sort operations when multithreaded sorting +** is enabled (using the [PRAGMA threads] command) and the amount of content +** to be sorted exceeds the page size times the minimum of the +** [PRAGMA cache_size] setting and this value. +** +** [[SQLITE_CONFIG_STMTJRNL_SPILL]] +**
SQLITE_CONFIG_STMTJRNL_SPILL +**
^The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which +** becomes the [statement journal] spill-to-disk threshold. +** [Statement journals] are held in memory until their size (in bytes) +** exceeds this threshold, at which point they are written to disk. +** Or if the threshold is -1, statement journals are always held +** exclusively in memory. +** Since many statement journals never become large, setting the spill +** threshold to a value such as 64KiB can greatly reduce the amount of +** I/O required to support statement rollback. +** The default value for this setting is controlled by the +** [SQLITE_STMTJRNL_SPILL] compile-time option. +** +** [[SQLITE_CONFIG_SORTERREF_SIZE]] +**
SQLITE_CONFIG_SORTERREF_SIZE +**
The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter +** of type (int) - the new value of the sorter-reference size threshold. +** Usually, when SQLite uses an external sort to order records according +** to an ORDER BY clause, all fields required by the caller are present in the +** sorted records. However, if SQLite determines based on the declared type +** of a table column that its values are likely to be very large - larger +** than the configured sorter-reference size threshold - then a reference +** is stored in each sorted record and the required column values loaded +** from the database as records are returned in sorted order. The default +** value for this option is to never use this optimization. Specifying a +** negative value for this option restores the default behaviour. +** This option is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option. +** +** [[SQLITE_CONFIG_MEMDB_MAXSIZE]] +**
SQLITE_CONFIG_MEMDB_MAXSIZE +**
The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter +** [sqlite3_int64] parameter which is the default maximum size for an in-memory +** database created using [sqlite3_deserialize()]. This default maximum +** size can be adjusted up or down for individual databases using the +** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this +** configuration setting is never used, then the default maximum is determined +** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that +** compile-time option is not set, then the default maximum is 1073741824. +**
+*/ +#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ +#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ +#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ +#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */ +#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ +#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ +#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ +#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ +#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ +/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ +#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ +#define SQLITE_CONFIG_PCACHE 14 /* no-op */ +#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ +#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ +#define SQLITE_CONFIG_URI 17 /* int */ +#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ +#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */ +#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */ +#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */ +#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */ +#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */ +#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */ +#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */ +#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */ + +/* +** CAPI3REF: Database Connection Configuration Options +** +** These constants are the available integer configuration options that +** can be passed as the second argument to the [sqlite3_db_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_db_config()] to make sure that +** the call worked. ^The [sqlite3_db_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+** [[SQLITE_DBCONFIG_LOOKASIDE]] +**
SQLITE_DBCONFIG_LOOKASIDE
+**
^This option takes three additional arguments that determine the +** [lookaside memory allocator] configuration for the [database connection]. +** ^The first argument (the third parameter to [sqlite3_db_config()] is a +** pointer to a memory buffer to use for lookaside memory. +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb +** may be NULL in which case SQLite will allocate the +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the +** size of each lookaside buffer slot. ^The third argument is the number of +** slots. The size of the buffer in the first argument must be greater than +** or equal to the product of the second and third arguments. The buffer +** must be aligned to an 8-byte boundary. ^If the second argument to +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally +** rounded down to the next smaller multiple of 8. ^(The lookaside memory +** configuration for a database connection can only be changed when that +** connection is not currently using lookaside memory, or in other words +** when the "current value" returned by +** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero. +** Any attempt to change the lookaside memory configuration when lookaside +** memory is in use leaves the configuration unchanged and returns +** [SQLITE_BUSY].)^
+** +** [[SQLITE_DBCONFIG_ENABLE_FKEY]] +**
SQLITE_DBCONFIG_ENABLE_FKEY
+**
^This option is used to enable or disable the enforcement of +** [foreign key constraints]. There should be two additional arguments. +** The first argument is an integer which is 0 to disable FK enforcement, +** positive to enable FK enforcement or negative to leave FK enforcement +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether FK enforcement is off or on +** following this call. The second parameter may be a NULL pointer, in +** which case the FK enforcement setting is not reported back.
+** +** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] +**
SQLITE_DBCONFIG_ENABLE_TRIGGER
+**
^This option is used to enable or disable [CREATE TRIGGER | triggers]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable triggers, +** positive to enable triggers or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether triggers are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the trigger setting is not reported back. +** +**

Originally this option disabled all triggers. ^(However, since +** SQLite version 3.35.0, TEMP triggers are still allowed even if +** this option is off. So, in other words, this option now only disables +** triggers in the main database schema or in the schemas of ATTACH-ed +** databases.)^

+** +** [[SQLITE_DBCONFIG_ENABLE_VIEW]] +**
SQLITE_DBCONFIG_ENABLE_VIEW
+**
^This option is used to enable or disable [CREATE VIEW | views]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable views, +** positive to enable views or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether views are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the view setting is not reported back. +** +**

Originally this option disabled all views. ^(However, since +** SQLite version 3.35.0, TEMP views are still allowed even if +** this option is off. So, in other words, this option now only disables +** views in the main database schema or in the schemas of ATTACH-ed +** databases.)^

+** +** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] +**
SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
+**
^This option is used to enable or disable the +** [fts3_tokenizer()] function which is part of the +** [FTS3] full-text search engine extension. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable fts3_tokenizer() or +** positive to enable fts3_tokenizer() or negative to leave the setting +** unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether fts3_tokenizer is disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the new setting is not reported back.
+** +** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] +**
SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
+**
^This option is used to enable or disable the [sqlite3_load_extension()] +** interface independently of the [load_extension()] SQL function. +** The [sqlite3_enable_load_extension()] API enables or disables both the +** C-API [sqlite3_load_extension()] and the SQL function [load_extension()]. +** There should be two additional arguments. +** When the first argument to this interface is 1, then only the C-API is +** enabled and the SQL function remains disabled. If the first argument to +** this interface is 0, then both the C-API and the SQL function are disabled. +** If the first argument is -1, then no changes are made to state of either the +** C-API or the SQL function. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether [sqlite3_load_extension()] interface +** is disabled or enabled following this call. The second parameter may +** be a NULL pointer, in which case the new setting is not reported back. +**
+** +** [[SQLITE_DBCONFIG_MAINDBNAME]]
SQLITE_DBCONFIG_MAINDBNAME
+**
^This option is used to change the name of the "main" database +** schema. ^The sole argument is a pointer to a constant UTF8 string +** which will become the new schema name in place of "main". ^SQLite +** does not make a copy of the new main schema name string, so the application +** must ensure that the argument passed into this DBCONFIG option is unchanged +** until after the database connection closes. +**
+** +** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]] +**
SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
+**
Usually, when a database in wal mode is closed or detached from a +** database handle, SQLite checks if this will mean that there are now no +** connections at all to the database. If so, it performs a checkpoint +** operation before closing the connection. This option may be used to +** override this behaviour. The first parameter passed to this operation +** is an integer - positive to disable checkpoints-on-close, or zero (the +** default) to enable them, and negative to leave the setting unchanged. +** The second parameter is a pointer to an integer +** into which is written 0 or 1 to indicate whether checkpoints-on-close +** have been disabled - 0 if they are not disabled, 1 if they are. +**
+** +** [[SQLITE_DBCONFIG_ENABLE_QPSG]]
SQLITE_DBCONFIG_ENABLE_QPSG
+**
^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates +** the [query planner stability guarantee] (QPSG). When the QPSG is active, +** a single SQL query statement will always use the same algorithm regardless +** of values of [bound parameters].)^ The QPSG disables some query optimizations +** that look at the values of bound parameters, which can make some queries +** slower. But the QPSG has the advantage of more predictable behavior. With +** the QPSG active, SQLite will always use the same query plan in the field as +** was used during testing in the lab. +** The first argument to this setting is an integer which is 0 to disable +** the QPSG, positive to enable QPSG, or negative to leave the setting +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether the QPSG is disabled or enabled +** following this call. +**
+** +** [[SQLITE_DBCONFIG_TRIGGER_EQP]]
SQLITE_DBCONFIG_TRIGGER_EQP
+**
By default, the output of EXPLAIN QUERY PLAN commands does not +** include output for any operations performed by trigger programs. This +** option is used to set or clear (the default) a flag that governs this +** behavior. The first parameter passed to this operation is an integer - +** positive to enable output for trigger programs, or zero to disable it, +** or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which is written +** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if +** it is not disabled, 1 if it is. +**
+** +** [[SQLITE_DBCONFIG_RESET_DATABASE]]
SQLITE_DBCONFIG_RESET_DATABASE
+**
Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run +** [VACUUM] in order to reset a database back to an empty database +** with no schema and no content. The following process works even for +** a badly corrupted database file: +**
    +**
  1. If the database connection is newly opened, make sure it has read the +** database schema by preparing then discarding some query against the +** database, or calling sqlite3_table_column_metadata(), ignoring any +** errors. This step is only necessary if the application desires to keep +** the database in WAL mode after the reset if it was in WAL mode before +** the reset. +**
  2. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); +**
  3. [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); +**
  4. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0); +**
+** Because resetting a database is destructive and irreversible, the +** process requires the use of this obscure API and multiple steps to help +** ensure that it does not happen by accident. +** +** [[SQLITE_DBCONFIG_DEFENSIVE]]
SQLITE_DBCONFIG_DEFENSIVE
+**
The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the +** "defensive" flag for a database connection. When the defensive +** flag is enabled, language features that allow ordinary SQL to +** deliberately corrupt the database file are disabled. The disabled +** features include but are not limited to the following: +**
    +**
  • The [PRAGMA writable_schema=ON] statement. +**
  • The [PRAGMA journal_mode=OFF] statement. +**
  • Writes to the [sqlite_dbpage] virtual table. +**
  • Direct writes to [shadow tables]. +**
+**
+** +** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]]
SQLITE_DBCONFIG_WRITABLE_SCHEMA
+**
The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the +** "writable_schema" flag. This has the same effect and is logically equivalent +** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. +** The first argument to this setting is an integer which is 0 to disable +** the writable_schema, positive to enable writable_schema, or negative to +** leave the setting unchanged. The second parameter is a pointer to an +** integer into which is written 0 or 1 to indicate whether the writable_schema +** is enabled or disabled following this call. +**
+** +** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]] +**
SQLITE_DBCONFIG_LEGACY_ALTER_TABLE
+**
The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates +** the legacy behavior of the [ALTER TABLE RENAME] command such it +** behaves as it did prior to [version 3.24.0] (2018-06-04). See the +** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for +** additional information. This feature can also be turned on and off +** using the [PRAGMA legacy_alter_table] statement. +**
+** +** [[SQLITE_DBCONFIG_DQS_DML]] +**
SQLITE_DBCONFIG_DQS_DML +**
The SQLITE_DBCONFIG_DQS_DML option activates or deactivates +** the legacy [double-quoted string literal] misfeature for DML statements +** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The +** default value of this setting is determined by the [-DSQLITE_DQS] +** compile-time option. +**
+** +** [[SQLITE_DBCONFIG_DQS_DDL]] +**
SQLITE_DBCONFIG_DQS_DDL +**
The SQLITE_DBCONFIG_DQS option activates or deactivates +** the legacy [double-quoted string literal] misfeature for DDL statements, +** such as CREATE TABLE and CREATE INDEX. The +** default value of this setting is determined by the [-DSQLITE_DQS] +** compile-time option. +**
+** +** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]] +**
SQLITE_DBCONFIG_TRUSTED_SCHEMA +**
The SQLITE_DBCONFIG_TRUSTED_SCHEMA option tells SQLite to +** assume that database schemas are untainted by malicious content. +** When the SQLITE_DBCONFIG_TRUSTED_SCHEMA option is disabled, SQLite +** takes additional defensive steps to protect the application from harm +** including: +**
    +**
  • Prohibit the use of SQL functions inside triggers, views, +** CHECK constraints, DEFAULT clauses, expression indexes, +** partial indexes, or generated columns +** unless those functions are tagged with [SQLITE_INNOCUOUS]. +**
  • Prohibit the use of virtual tables inside of triggers or views +** unless those virtual tables are tagged with [SQLITE_VTAB_INNOCUOUS]. +**
+** This setting defaults to "on" for legacy compatibility, however +** all applications are advised to turn it off if possible. This setting +** can also be controlled using the [PRAGMA trusted_schema] statement. +**
+** +** [[SQLITE_DBCONFIG_LEGACY_FILE_FORMAT]] +**
SQLITE_DBCONFIG_LEGACY_FILE_FORMAT +**
The SQLITE_DBCONFIG_LEGACY_FILE_FORMAT option activates or deactivates +** the legacy file format flag. When activated, this flag causes all newly +** created database file to have a schema format version number (the 4-byte +** integer found at offset 44 into the database header) of 1. This in turn +** means that the resulting database file will be readable and writable by +** any SQLite version back to 3.0.0 ([dateof:3.0.0]). Without this setting, +** newly created databases are generally not understandable by SQLite versions +** prior to 3.3.0 ([dateof:3.3.0]). As these words are written, there +** is now scarcely any need to generated database files that are compatible +** all the way back to version 3.0.0, and so this setting is of little +** practical use, but is provided so that SQLite can continue to claim the +** ability to generate new database files that are compatible with version +** 3.0.0. +**

Note that when the SQLITE_DBCONFIG_LEGACY_FILE_FORMAT setting is on, +** the [VACUUM] command will fail with an obscure error when attempting to +** process a table with generated columns and a descending index. This is +** not considered a bug since SQLite versions 3.3.0 and earlier do not support +** either generated columns or decending indexes. +**

+**
+*/ +#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */ +#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ +#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */ +#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */ +#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */ +#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */ +#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */ +#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */ +#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */ +#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */ +#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */ +#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */ +#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */ +#define SQLITE_DBCONFIG_MAX 1017 /* Largest DBCONFIG */ + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes +** METHOD: sqlite3 +** +** ^The sqlite3_extended_result_codes() routine enables or disables the +** [extended result codes] feature of SQLite. ^The extended result +** codes are disabled by default for historical compatibility. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid +** METHOD: sqlite3 +** +** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables) +** has a unique 64-bit signed +** integer key called the [ROWID | "rowid"]. ^The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. ^If +** the table has a column of type [INTEGER PRIMARY KEY] then that column +** is another alias for the rowid. +** +** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of +** the most recent successful [INSERT] into a rowid table or [virtual table] +** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not +** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred +** on the database connection D, then sqlite3_last_insert_rowid(D) returns +** zero. +** +** As well as being set automatically as rows are inserted into database +** tables, the value returned by this function may be set explicitly by +** [sqlite3_set_last_insert_rowid()] +** +** Some virtual table implementations may INSERT rows into rowid tables as +** part of committing a transaction (e.g. to flush data accumulated in memory +** to disk). In this case subsequent calls to this function return the rowid +** associated with these internal INSERT operations, which leads to +** unintuitive results. Virtual table implementations that do write to rowid +** tables in this way can avoid this problem by restoring the original +** rowid value using [sqlite3_set_last_insert_rowid()] before returning +** control to the user. +** +** ^(If an [INSERT] occurs within a trigger then this routine will +** return the [rowid] of the inserted row as long as the trigger is +** running. Once the trigger program ends, the value returned +** by this routine reverts to what it was before the trigger was fired.)^ +** +** ^An [INSERT] that fails due to a constraint violation is not a +** successful [INSERT] and does not change the value returned by this +** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. ^(When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface.)^ +** +** ^For the purposes of this routine, an [INSERT] is considered to +** be successful even if it is subsequently rolled back. +** +** This function is accessible to SQL statements via the +** [last_insert_rowid() SQL function]. +** +** If a separate thread performs a new [INSERT] on the same +** database connection while the [sqlite3_last_insert_rowid()] +** function is running and thus changes the last insert [rowid], +** then the value returned by [sqlite3_last_insert_rowid()] is +** unpredictable and might not equal either the old or the new +** last insert [rowid]. +*/ +SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Set the Last Insert Rowid value. +** METHOD: sqlite3 +** +** The sqlite3_set_last_insert_rowid(D, R) method allows the application to +** set the value returned by calling sqlite3_last_insert_rowid(D) to R +** without inserting a row into the database. +*/ +SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); + +/* +** CAPI3REF: Count The Number Of Rows Modified +** METHOD: sqlite3 +** +** ^This function returns the number of rows modified, inserted or +** deleted by the most recently completed INSERT, UPDATE or DELETE +** statement on the database connection specified by the only parameter. +** ^Executing any other type of SQL statement does not modify the value +** returned by this function. +** +** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are +** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], +** [foreign key actions] or [REPLACE] constraint resolution are not counted. +** +** Changes to a view that are intercepted by +** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value +** returned by sqlite3_changes() immediately after an INSERT, UPDATE or +** DELETE statement run on a view is always zero. Only changes made to real +** tables are counted. +** +** Things are more complicated if the sqlite3_changes() function is +** executed while a trigger program is running. This may happen if the +** program uses the [changes() SQL function], or if some other callback +** function invokes sqlite3_changes() directly. Essentially: +** +** +** +** ^This means that if the changes() SQL function (or similar) is used +** by the first INSERT, UPDATE or DELETE statement within a trigger, it +** returns the value as set when the calling statement began executing. +** ^If it is used by the second or subsequent such statement within a trigger +** program, the value returned reflects the number of rows modified by the +** previous INSERT, UPDATE or DELETE statement within the same trigger. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_changes()] is running then the value returned +** is unpredictable and not meaningful. +** +** See also: +** +*/ +SQLITE_API int sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified +** METHOD: sqlite3 +** +** ^This function returns the total number of rows inserted, modified or +** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed +** since the database connection was opened, including those executed as +** part of trigger programs. ^Executing any other type of SQL statement +** does not affect the value returned by sqlite3_total_changes(). +** +** ^Changes made as part of [foreign key actions] are included in the +** count, but those made as part of REPLACE constraint resolution are +** not. ^Changes to a view that are intercepted by INSTEAD OF triggers +** are not counted. +** +** The [sqlite3_total_changes(D)] interface only reports the number +** of rows that changed due to SQL statement run against database +** connection D. Any changes by other database connections are ignored. +** To detect changes against a database file from other database +** connections use the [PRAGMA data_version] command or the +** [SQLITE_FCNTL_DATA_VERSION] [file control]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_total_changes()] is running then the value +** returned is unpredictable and not meaningful. +** +** See also: +** +*/ +SQLITE_API int sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query +** METHOD: sqlite3 +** +** ^This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** ^It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. But it +** is not safe to call this routine with a [database connection] that +** is closed or might close before sqlite3_interrupt() returns. +** +** ^If an SQL operation is very nearly finished at the time when +** sqlite3_interrupt() is called, then it might not have an opportunity +** to be interrupted and might continue to completion. +** +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE +** that is inside an explicit transaction, then the entire transaction +** will be rolled back automatically. +** +** ^The sqlite3_interrupt(D) call is in effect until all currently running +** SQL statements on [database connection] D complete. ^Any new SQL statements +** that are started after the sqlite3_interrupt() call and before the +** running statement count reaches zero are interrupted as if they had been +** running prior to the sqlite3_interrupt() call. ^New SQL statements +** that are started after the running statement count reaches zero are +** not effected by the sqlite3_interrupt(). +** ^A call to sqlite3_interrupt(D) that occurs when there are no running +** SQL statements is a no-op and has no effect on SQL statements +** that are started after the sqlite3_interrupt() call returns. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete +** +** These routines are useful during command-line input to determine if the +** currently entered text seems to form a complete SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. ^These routines return 1 if the input string +** appears to be a complete SQL statement. ^A statement is judged to be +** complete if it ends with a semicolon token and is not a prefix of a +** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within +** string literals or quoted identifier names or comments are not +** independent tokens (they are part of the token in which they are +** embedded) and thus do not count as a statement terminator. ^Whitespace +** and comments that follow the final semicolon are ignored. +** +** ^These routines return 0 if the statement is incomplete. ^If a +** memory allocation fails, then SQLITE_NOMEM is returned. +** +** ^These routines do not parse the SQL statements thus +** will not detect syntactically incorrect SQL. +** +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior +** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked +** automatically by sqlite3_complete16(). If that initialization fails, +** then the return value from sqlite3_complete16() will be non-zero +** regardless of whether or not the input SQL is complete.)^ +** +** The input to [sqlite3_complete()] must be a zero-terminated +** UTF-8 string. +** +** The input to [sqlite3_complete16()] must be a zero-terminated +** UTF-16 string in native byte order. +*/ +SQLITE_API int sqlite3_complete(const char *sql); +SQLITE_API int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors +** KEYWORDS: {busy-handler callback} {busy handler} +** METHOD: sqlite3 +** +** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X +** that might be invoked with argument P whenever +** an attempt is made to access a database table associated with +** [database connection] D when another thread +** or process has the table locked. +** The sqlite3_busy_handler() interface is used to implement +** [sqlite3_busy_timeout()] and [PRAGMA busy_timeout]. +** +** ^If the busy callback is NULL, then [SQLITE_BUSY] +** is returned immediately upon encountering the lock. ^If the busy callback +** is not NULL, then the callback might be invoked with two arguments. +** +** ^The first argument to the busy handler is a copy of the void* pointer which +** is the third argument to sqlite3_busy_handler(). ^The second argument to +** the busy handler callback is the number of times that the busy handler has +** been invoked previously for the same locking event. ^If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] is returned +** to the application. +** ^If the callback returns non-zero, then another attempt +** is made to access the database and the cycle repeats. +** +** The presence of a busy handler does not guarantee that it will be invoked +** when there is lock contention. ^If SQLite determines that invoking the busy +** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] +** to the application instead of invoking the +** busy handler. +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** ^The default busy callback is NULL. +** +** ^(There can only be a single busy handler defined for each +** [database connection]. Setting a new busy handler clears any +** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] +** or evaluating [PRAGMA busy_timeout=N] will change the +** busy handler and thus clear any previously set busy handler. +** +** The busy callback should not take any actions which modify the +** database connection that invoked the busy handler. In other words, +** the busy handler is not reentrant. Any such actions +** result in undefined behavior. +** +** A busy handler must not close the database connection +** or [prepared statement] that invoked the busy handler. +*/ +SQLITE_API int sqlite3_busy_handler(sqlite3*,int(*)(void*,int),void*); + +/* +** CAPI3REF: Set A Busy Timeout +** METHOD: sqlite3 +** +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps +** for a specified amount of time when a table is locked. ^The handler +** will sleep multiple times until at least "ms" milliseconds of sleeping +** have accumulated. ^After at least "ms" milliseconds of sleeping, +** the handler returns 0 which causes [sqlite3_step()] to return +** [SQLITE_BUSY]. +** +** ^Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** ^(There can only be a single busy handler for a particular +** [database connection] at any given moment. If another busy handler +** was defined (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared.)^ +** +** See also: [PRAGMA busy_timeout] +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries +** METHOD: sqlite3 +** +** This is a legacy interface that is preserved for backwards compatibility. +** Use of this interface is not recommended. +** +** Definition: A result table is memory data structure created by the +** [sqlite3_get_table()] interface. A result table records the +** complete query results from one or more queries. +** +** The table conceptually has a number of rows and columns. But +** these numbers are not part of the result table itself. These +** numbers are obtained separately. Let N be the number of rows +** and M be the number of columns. +** +** A result table is an array of pointers to zero-terminated UTF-8 strings. +** There are (N+1)*M elements in the array. The first M pointers point +** to zero-terminated strings that contain the names of the columns. +** The remaining entries all point to query results. NULL values result +** in NULL pointers. All other values are in their UTF-8 zero-terminated +** string representation as returned by [sqlite3_column_text()]. +** +** A result table might consist of one or more memory allocations. +** It is not safe to pass a result table directly to [sqlite3_free()]. +** A result table should be deallocated using [sqlite3_free_table()]. +** +** ^(As an example of the result table format, suppose a query result +** is as follows: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** There are two columns (M==2) and three rows (N==3). Thus the +** result table has 8 entries. Suppose the result table is stored +** in an array named azResult. Then azResult holds this content: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
)^ +** +** ^The sqlite3_get_table() function evaluates one or more +** semicolon-separated SQL statements in the zero-terminated UTF-8 +** string of its 2nd parameter and returns a result table to the +** pointer given in its 3rd parameter. +** +** After the application has finished with the result from sqlite3_get_table(), +** it must pass the result table pointer to sqlite3_free_table() in order to +** release the memory that was malloced. Because of the way the +** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling +** function must not try to call [sqlite3_free()] directly. Only +** [sqlite3_free_table()] is able to release the memory properly and safely. +** +** The sqlite3_get_table() interface is implemented as a wrapper around +** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access +** to any internal data structures of SQLite. It uses only the public +** interface defined here. As a consequence, errors that occur in the +** wrapper layer outside of the internal [sqlite3_exec()] call are not +** reflected in subsequent calls to [sqlite3_errcode()] or +** [sqlite3_errmsg()]. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + char ***pazResult, /* Results of the query */ + int *pnRow, /* Number of result rows written here */ + int *pnColumn, /* Number of result columns written here */ + char **pzErrmsg /* Error msg written here */ +); +SQLITE_API void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions +** +** These routines are work-alikes of the "printf()" family of functions +** from the standard C library. +** These routines understand most of the common formatting options from +** the standard library printf() +** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]). +** See the [built-in printf()] documentation for details. +** +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc64()]. +** The strings returned by these two routines should be +** released by [sqlite3_free()]. ^Both routines return a +** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough +** memory to hold the resulting string. +** +** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. Note that the order of the +** first two parameters is reversed from snprintf().)^ This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. ^(Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer.)^ We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** ^As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. ^The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. So the longest string that can be completely +** written will be n-1 characters. +** +** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). +** +** See also: [built-in printf()], [printf() SQL function] +*/ +SQLITE_API char *sqlite3_mprintf(const char*,...); +SQLITE_API char *sqlite3_vmprintf(const char*, va_list); +SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); +SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list); + +/* +** CAPI3REF: Memory Allocation Subsystem +** +** The SQLite core uses these three routines for all of its own +** internal memory allocation needs. "Core" in the previous sentence +** does not include operating-system specific [VFS] implementation. The +** Windows VFS uses native malloc() and free() for some operations. +** +** ^The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** ^If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. ^If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** ^The sqlite3_malloc64(N) routine works just like +** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead +** of a signed 32-bit integer. +** +** ^Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. ^The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_realloc(). +** +** ^The sqlite3_realloc(X,N) interface attempts to resize a +** prior memory allocation X to be at least N bytes. +** ^If the X parameter to sqlite3_realloc(X,N) +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N). +** ^If the N parameter to sqlite3_realloc(X,N) is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(X). +** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation +** of at least N bytes in size or NULL if insufficient memory is available. +** ^If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc(X,N) and the prior allocation is freed. +** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the +** prior allocation is not freed. +** +** ^The sqlite3_realloc64(X,N) interfaces works the same as +** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead +** of a 32-bit signed integer. +** +** ^If X is a memory allocation previously obtained from sqlite3_malloc(), +** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then +** sqlite3_msize(X) returns the size of that memory allocation in bytes. +** ^The value returned by sqlite3_msize(X) might be larger than the number +** of bytes requested when X was allocated. ^If X is a NULL pointer then +** sqlite3_msize(X) returns zero. If X points to something that is not +** the beginning of memory allocation, or if it points to a formerly +** valid memory allocation that has now been freed, then the behavior +** of sqlite3_msize(X) is undefined and possibly harmful. +** +** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(), +** sqlite3_malloc64(), and sqlite3_realloc64() +** is always aligned to at least an 8 byte boundary, or to a +** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time +** option is used. +** +** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] +** must be either NULL or else pointers obtained from a prior +** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have +** not yet been released. +** +** The application must not read or write any part of +** a block of memory after it has been released using +** [sqlite3_free()] or [sqlite3_realloc()]. +*/ +SQLITE_API void *sqlite3_malloc(int); +SQLITE_API void *sqlite3_malloc64(sqlite3_uint64); +SQLITE_API void *sqlite3_realloc(void*, int); +SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64); +SQLITE_API void sqlite3_free(void*); +SQLITE_API sqlite3_uint64 sqlite3_msize(void*); + +/* +** CAPI3REF: Memory Allocator Statistics +** +** SQLite provides these two interfaces for reporting on the status +** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] +** routines, which form the built-in memory allocation subsystem. +** +** ^The [sqlite3_memory_used()] routine returns the number of bytes +** of memory currently outstanding (malloced but not freed). +** ^The [sqlite3_memory_highwater()] routine returns the maximum +** value of [sqlite3_memory_used()] since the high-water mark +** was last reset. ^The values returned by [sqlite3_memory_used()] and +** [sqlite3_memory_highwater()] include any overhead +** added by SQLite in its implementation of [sqlite3_malloc()], +** but not overhead added by the any underlying system library +** routines that [sqlite3_malloc()] may call. +** +** ^The memory high-water mark is reset to the current value of +** [sqlite3_memory_used()] if and only if the parameter to +** [sqlite3_memory_highwater()] is true. ^The value returned +** by [sqlite3_memory_highwater(1)] is the high-water mark +** prior to the reset. +*/ +SQLITE_API sqlite3_int64 sqlite3_memory_used(void); +SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Pseudo-Random Number Generator +** +** SQLite contains a high-quality pseudo-random number generator (PRNG) used to +** select random [ROWID | ROWIDs] when inserting new records into a table that +** already uses the largest possible [ROWID]. The PRNG is also used for +** the built-in random() and randomblob() SQL functions. This interface allows +** applications to access the same PRNG for other purposes. +** +** ^A call to this routine stores N bytes of randomness into buffer P. +** ^The P parameter can be a NULL pointer. +** +** ^If this routine has not been previously called or if the previous +** call had N less than one or a NULL pointer for P, then the PRNG is +** seeded using randomness obtained from the xRandomness method of +** the default [sqlite3_vfs] object. +** ^If the previous call to this routine had an N of 1 or more and a +** non-NULL P then the pseudo-randomness is generated +** internally and without recourse to the [sqlite3_vfs] xRandomness +** method. +*/ +SQLITE_API void sqlite3_randomness(int N, void *P); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks +** METHOD: sqlite3 +** KEYWORDS: {authorizer callback} +** +** ^This routine registers an authorizer callback with a particular +** [database connection], supplied in the first argument. +** ^The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()], +** and [sqlite3_prepare16_v3()]. ^At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. ^The authorizer callback should +** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. ^If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then the [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer will fail with an error message. +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. ^When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer will fail with an error message explaining that +** access is denied. +** +** ^The first parameter to the authorizer callback is a copy of the third +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter +** to the callback is an integer [SQLITE_COPY | action code] that specifies +** the particular action to be authorized. ^The third through sixth parameters +** to the callback are either NULL pointers or zero-terminated strings +** that contain additional details about the action to be authorized. +** Applications must always be prepared to encounter a NULL pointer in any +** of the third through the sixth parameters of the authorization callback. +** +** ^If the action code is [SQLITE_READ] +** and the callback returns [SQLITE_IGNORE] then the +** [prepared statement] statement is constructed to substitute +** a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] +** return can be used to deny an untrusted user access to individual +** columns of a table. +** ^When a table is referenced by a [SELECT] but no column values are +** extracted from that table (for example in a query like +** "SELECT count(*) FROM tab") then the [SQLITE_READ] authorizer callback +** is invoked once for that table with a column name that is an empty string. +** ^If the action code is [SQLITE_DELETE] and the callback returns +** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the +** [truncate optimization] is disabled and all rows are deleted individually. +** +** An authorizer is used when [sqlite3_prepare | preparing] +** SQL statements from an untrusted source, to ensure that the SQL statements +** do not try to access data they are not allowed to see, or that they do not +** try to execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being [sqlite3_prepare | prepared] that +** disallows everything except [SELECT] statements. +** +** Applications that need to process SQL from untrusted sources +** might also consider lowering resource limits using [sqlite3_limit()] +** and limiting database size using the [max_page_count] [PRAGMA] +** in addition to using an authorizer. +** +** ^(Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call.)^ ^Disable the authorizer by installing a NULL callback. +** The authorizer is disabled by default. +** +** The authorizer callback must not do anything that will modify +** the database connection that invoked the authorizer callback. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the +** statement might be re-prepared during [sqlite3_step()] due to a +** schema change. Hence, the application should ensure that the +** correct authorizer callback remains in place during the [sqlite3_step()]. +** +** ^Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. Authorization is not +** performed during statement evaluation in [sqlite3_step()], unless +** as stated in the previous paragraph, sqlite3_step() invokes +** sqlite3_prepare_v2() to reprepare a statement after a schema change. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +** +** Note that SQLITE_IGNORE is also used as a [conflict resolution mode] +** returned from the [sqlite3_vtab_on_conflict()] interface. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorize certain SQL statement actions. The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. +** +** These action code values signify what kind of operation is to be +** authorized. The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. ^(The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* Operation NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* NULL Function Name */ +#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ +#define SQLITE_COPY 0 /* No longer used */ +#define SQLITE_RECURSIVE 33 /* NULL NULL */ + +/* +** CAPI3REF: Tracing And Profiling Functions +** METHOD: sqlite3 +** +** These routines are deprecated. Use the [sqlite3_trace_v2()] interface +** instead of the routines described here. +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** ^The callback function registered by sqlite3_trace() is invoked at +** various times when an SQL statement is being run by [sqlite3_step()]. +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the +** SQL statement text as the statement first begins executing. +** ^(Additional sqlite3_trace() callbacks might occur +** as each triggered subprogram is entered. The callbacks for triggers +** contain a UTF-8 SQL comment that identifies the trigger.)^ +** +** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit +** the length of [bound parameter] expansion in the output of sqlite3_trace(). +** +** ^The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. ^The profile callback contains +** the original statement text and an estimate of wall-clock time +** of how long that statement took to run. ^The profile callback +** time is in units of nanoseconds, however the current implementation +** is only capable of millisecond resolution so the six least significant +** digits in the time are meaningless. Future versions of SQLite +** might provide greater resolution on the profiler callback. Invoking +** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the +** profile callback. +*/ +SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*, + void(*xTrace)(void*,const char*), void*); +SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: SQL Trace Event Codes +** KEYWORDS: SQLITE_TRACE +** +** These constants identify classes of events that can be monitored +** using the [sqlite3_trace_v2()] tracing logic. The M argument +** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of +** the following constants. ^The first argument to the trace callback +** is one of the following constants. +** +** New tracing constants may be added in future releases. +** +** ^A trace callback has four arguments: xCallback(T,C,P,X). +** ^The T argument is one of the integer type codes above. +** ^The C argument is a copy of the context pointer passed in as the +** fourth argument to [sqlite3_trace_v2()]. +** The P and X arguments are pointers whose meanings depend on T. +** +**
+** [[SQLITE_TRACE_STMT]]
SQLITE_TRACE_STMT
+**
^An SQLITE_TRACE_STMT callback is invoked when a prepared statement +** first begins running and possibly at other times during the +** execution of the prepared statement, such as at the start of each +** trigger subprogram. ^The P argument is a pointer to the +** [prepared statement]. ^The X argument is a pointer to a string which +** is the unexpanded SQL text of the prepared statement or an SQL comment +** that indicates the invocation of a trigger. ^The callback can compute +** the same text that would have been returned by the legacy [sqlite3_trace()] +** interface by using the X argument when X begins with "--" and invoking +** [sqlite3_expanded_sql(P)] otherwise. +** +** [[SQLITE_TRACE_PROFILE]]
SQLITE_TRACE_PROFILE
+**
^An SQLITE_TRACE_PROFILE callback provides approximately the same +** information as is provided by the [sqlite3_profile()] callback. +** ^The P argument is a pointer to the [prepared statement] and the +** X argument points to a 64-bit integer which is the estimated of +** the number of nanosecond that the prepared statement took to run. +** ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes. +** +** [[SQLITE_TRACE_ROW]]
SQLITE_TRACE_ROW
+**
^An SQLITE_TRACE_ROW callback is invoked whenever a prepared +** statement generates a single row of result. +** ^The P argument is a pointer to the [prepared statement] and the +** X argument is unused. +** +** [[SQLITE_TRACE_CLOSE]]
SQLITE_TRACE_CLOSE
+**
^An SQLITE_TRACE_CLOSE callback is invoked when a database +** connection closes. +** ^The P argument is a pointer to the [database connection] object +** and the X argument is unused. +**
+*/ +#define SQLITE_TRACE_STMT 0x01 +#define SQLITE_TRACE_PROFILE 0x02 +#define SQLITE_TRACE_ROW 0x04 +#define SQLITE_TRACE_CLOSE 0x08 + +/* +** CAPI3REF: SQL Trace Hook +** METHOD: sqlite3 +** +** ^The sqlite3_trace_v2(D,M,X,P) interface registers a trace callback +** function X against [database connection] D, using property mask M +** and context pointer P. ^If the X callback is +** NULL or if the M mask is zero, then tracing is disabled. The +** M argument should be the bitwise OR-ed combination of +** zero or more [SQLITE_TRACE] constants. +** +** ^Each call to either sqlite3_trace() or sqlite3_trace_v2() overrides +** (cancels) any prior calls to sqlite3_trace() or sqlite3_trace_v2(). +** +** ^The X callback is invoked whenever any of the events identified by +** mask M occur. ^The integer return value from the callback is currently +** ignored, though this may change in future releases. Callback +** implementations should return zero to ensure future compatibility. +** +** ^A trace callback is invoked with four arguments: callback(T,C,P,X). +** ^The T argument is one of the [SQLITE_TRACE] +** constants to indicate why the callback was invoked. +** ^The C argument is a copy of the context pointer. +** The P and X arguments are pointers whose meanings depend on T. +** +** The sqlite3_trace_v2() interface is intended to replace the legacy +** interfaces [sqlite3_trace()] and [sqlite3_profile()], both of which +** are deprecated. +*/ +SQLITE_API int sqlite3_trace_v2( + sqlite3*, + unsigned uMask, + int(*xCallback)(unsigned,void*,void*,void*), + void *pCtx +); + +/* +** CAPI3REF: Query Progress Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback +** function X to be invoked periodically during long running calls to +** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for +** database connection D. An example use for this +** interface is to keep a GUI updated during a large query. +** +** ^The parameter P is passed through as the only parameter to the +** callback function X. ^The parameter N is the approximate number of +** [virtual machine instructions] that are evaluated between successive +** invocations of the callback X. ^If N is less than one then the progress +** handler is disabled. +** +** ^Only a single progress handler may be defined at one time per +** [database connection]; setting a new progress handler cancels the +** old one. ^Setting parameter X to NULL disables the progress handler. +** ^The progress handler is also disabled by setting N to a value less +** than 1. +** +** ^If the progress callback returns non-zero, the operation is +** interrupted. This feature can be used to implement a +** "Cancel" button on a GUI progress dialog box. +** +** The progress handler callback must not do anything that will modify +** the database connection that invoked the progress handler. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +*/ +SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection +** CONSTRUCTOR: sqlite3 +** +** ^These routines open an SQLite database file as specified by the +** filename argument. ^The filename argument is interpreted as UTF-8 for +** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte +** order for sqlite3_open16(). ^(A [database connection] handle is usually +** returned in *ppDb, even if an error occurs. The only exception is that +** if SQLite is unable to allocate memory to hold the [sqlite3] object, +** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] +** object.)^ ^(If the database is opened (and/or created) successfully, then +** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error following a failure of any +** of the sqlite3_open() routines. +** +** ^The default encoding will be UTF-8 for databases created using +** sqlite3_open() or sqlite3_open_v2(). ^The default encoding for databases +** created using sqlite3_open16() will be UTF-16 in the native byte order. +** +** Whether or not an error occurs when it is opened, resources +** associated with the [database connection] handle should be released by +** passing it to [sqlite3_close()] when it is no longer required. +** +** The sqlite3_open_v2() interface works like sqlite3_open() +** except that it accepts two additional parameters for additional control +** over the new database connection. ^(The flags parameter to +** sqlite3_open_v2() must include, at a minimum, one of the following +** three flag combinations:)^ +** +**
+** ^(
[SQLITE_OPEN_READONLY]
+**
The database is opened in read-only mode. If the database does not +** already exist, an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE]
+**
The database is opened for reading and writing if possible, or reading +** only if the file is write protected by the operating system. In either +** case the database must already exist, otherwise an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+**
The database is opened for reading and writing, and is created if +** it does not already exist. This is the behavior that is always used for +** sqlite3_open() and sqlite3_open16().
)^ +**
+** +** In addition to the required flags, the following optional flags are +** also supported: +** +**
+** ^(
[SQLITE_OPEN_URI]
+**
The filename can be interpreted as a URI if this flag is set.
)^ +** +** ^(
[SQLITE_OPEN_MEMORY]
+**
The database will be opened as an in-memory database. The database +** is named by the "filename" argument for the purposes of cache-sharing, +** if shared cache mode is enabled, but the "filename" is otherwise ignored. +**
)^ +** +** ^(
[SQLITE_OPEN_NOMUTEX]
+**
The new database connection will use the "multi-thread" +** [threading mode].)^ This means that separate threads are allowed +** to use SQLite at the same time, as long as each thread is using +** a different [database connection]. +** +** ^(
[SQLITE_OPEN_FULLMUTEX]
+**
The new database connection will use the "serialized" +** [threading mode].)^ This means the multiple threads can safely +** attempt to use the same database connection at the same time. +** (Mutexes will block any actual concurrency, but in this mode +** there is no harm in trying.) +** +** ^(
[SQLITE_OPEN_SHAREDCACHE]
+**
The database is opened [shared cache] enabled, overriding +** the default shared cache setting provided by +** [sqlite3_enable_shared_cache()].)^ +** +** ^(
[SQLITE_OPEN_PRIVATECACHE]
+**
The database is opened [shared cache] disabled, overriding +** the default shared cache setting provided by +** [sqlite3_enable_shared_cache()].)^ +** +** [[OPEN_NOFOLLOW]] ^(
[SQLITE_OPEN_NOFOLLOW]
+**
The database filename is not allowed to be a symbolic link
+**
)^ +** +** If the 3rd parameter to sqlite3_open_v2() is not one of the +** required combinations shown above optionally combined with other +** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] +** then the behavior is undefined. +** +** ^The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system interface that +** the new database connection should use. ^If the fourth parameter is +** a NULL pointer then the default [sqlite3_vfs] object is used. +** +** ^If the filename is ":memory:", then a private, temporary in-memory database +** is created for the connection. ^This in-memory database will vanish when +** the database connection is closed. Future versions of SQLite might +** make use of additional special filenames that begin with the ":" character. +** It is recommended that when a database filename actually does begin with +** a ":" character you should prefix the filename with a pathname such as +** "./" to avoid ambiguity. +** +** ^If the filename is an empty string, then a private, temporary +** on-disk database will be created. ^This private database will be +** automatically deleted as soon as the database connection is closed. +** +** [[URI filenames in sqlite3_open()]]

URI Filenames

+** +** ^If [URI filename] interpretation is enabled, and the filename argument +** begins with "file:", then the filename is interpreted as a URI. ^URI +** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is +** set in the third argument to sqlite3_open_v2(), or if it has +** been enabled globally using the [SQLITE_CONFIG_URI] option with the +** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. +** URI filename interpretation is turned off +** by default, but future releases of SQLite might enable URI filename +** interpretation by default. See "[URI filenames]" for additional +** information. +** +** URI filenames are parsed according to RFC 3986. ^If the URI contains an +** authority, then it must be either an empty string or the string +** "localhost". ^If the authority is not an empty string or "localhost", an +** error is returned to the caller. ^The fragment component of a URI, if +** present, is ignored. +** +** ^SQLite uses the path component of the URI as the name of the disk file +** which contains the database. ^If the path begins with a '/' character, +** then it is interpreted as an absolute path. ^If the path does not begin +** with a '/' (meaning that the authority section is omitted from the URI) +** then the path is interpreted as a relative path. +** ^(On windows, the first component of an absolute path +** is a drive specification (e.g. "C:").)^ +** +** [[core URI query parameters]] +** The query component of a URI may contain parameters that are interpreted +** either by SQLite itself, or by a [VFS | custom VFS implementation]. +** SQLite and its built-in [VFSes] interpret the +** following query parameters: +** +** +** +** ^Specifying an unknown parameter in the query component of a URI is not an +** error. Future versions of SQLite might understand additional query +** parameters. See "[query parameters with special meaning to SQLite]" for +** additional information. +** +** [[URI filename examples]]

URI filename examples

+** +** +**
URI filenames Results +**
file:data.db +** Open the file "data.db" in the current directory. +**
file:/home/fred/data.db
+** file:///home/fred/data.db
+** file://localhost/home/fred/data.db
+** Open the database file "/home/fred/data.db". +**
file://darkstar/home/fred/data.db +** An error. "darkstar" is not a recognized authority. +**
+** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db +** Windows only: Open the file "data.db" on fred's desktop on drive +** C:. Note that the %20 escaping in this example is not strictly +** necessary - space characters can be used literally +** in URI filenames. +**
file:data.db?mode=ro&cache=private +** Open file "data.db" in the current directory for read-only access. +** Regardless of whether or not shared-cache mode is enabled by +** default, use a private cache. +**
file:/home/fred/data.db?vfs=unix-dotfile +** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile" +** that uses dot-files in place of posix advisory locking. +**
file:data.db?mode=readonly +** An error. "readonly" is not a valid option for the "mode" parameter. +** Use "ro" instead: "file:data.db?mode=ro". +**
+** +** ^URI hexadecimal escape sequences (%HH) are supported within the path and +** query components of a URI. A hexadecimal escape sequence consists of a +** percent sign - "%" - followed by exactly two hexadecimal digits +** specifying an octet value. ^Before the path or query components of a +** URI filename are interpreted, they are encoded using UTF-8 and all +** hexadecimal escape sequences replaced by a single byte containing the +** corresponding octet. If this process generates an invalid UTF-8 encoding, +** the results are undefined. +** +** Note to Windows users: The encoding used for the filename argument +** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] +*/ +SQLITE_API int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Obtain Values For URI Parameters +** +** These are utility routines, useful to [VFS|custom VFS implementations], +** that check if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of that query parameter. +** +** The first parameter to these interfaces (hereafter referred to +** as F) must be one of: +** +** If the F parameter is not one of the above, then the behavior is +** undefined and probably undesirable. Older versions of SQLite were +** more tolerant of invalid F parameters than newer versions. +** +** If F is a suitable filename (as described in the previous paragraph) +** and if P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F and it +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** The sqlite3_uri_key(F,N) returns a pointer to the name (not +** the value) of the N-th query parameter for filename F, or a NULL +** pointer if N is less than zero or greater than the number of query +** parameters minus 1. The N value is zero-based so N should be 0 to obtain +** the name of the first query parameter, 1 for the second parameter, and +** so forth. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that the SQLite core passed +** into the xOpen VFS method, then the behavior of this routine is undefined +** and probably undesirable. +** +** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F +** parameter can also be the name of a rollback journal file or WAL file +** in addition to the main database file. Prior to version 3.31.0, these +** routines would only work if F was the name of the main database file. +** When the F parameter is the name of the rollback journal or WAL file, +** it has access to all the same query parameters as were found on the +** main database file. +** +** See the [URI filename] documentation for additional information. +*/ +SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam); +SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64); +SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N); + +/* +** CAPI3REF: Translate filenames +** +** These routines are available to [VFS|custom VFS implementations] for +** translating filenames between the main database file, the journal file, +** and the WAL file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, then sqlite3_filename_database(F) +** returns the name of the corresponding database file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, or if F is a database filename +** obtained from [sqlite3_db_filename()], then sqlite3_filename_journal(F) +** returns the name of the corresponding rollback journal file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** that was passed by the SQLite core into the VFS, or if F is a database +** filename obtained from [sqlite3_db_filename()], then +** sqlite3_filename_wal(F) returns the name of the corresponding +** WAL file. +** +** In all of the above, if F is not the name of a database, journal or WAL +** filename passed into the VFS from the SQLite core and F is not the +** return value from [sqlite3_db_filename()], then the result is +** undefined and is likely a memory access violation. +*/ +SQLITE_API const char *sqlite3_filename_database(const char*); +SQLITE_API const char *sqlite3_filename_journal(const char*); +SQLITE_API const char *sqlite3_filename_wal(const char*); + +/* +** CAPI3REF: Database File Corresponding To A Journal +** +** ^If X is the name of a rollback or WAL-mode journal file that is +** passed into the xOpen method of [sqlite3_vfs], then +** sqlite3_database_file_object(X) returns a pointer to the [sqlite3_file] +** object that represents the main database file. +** +** This routine is intended for use in custom [VFS] implementations +** only. It is not a general-purpose interface. +** The argument sqlite3_file_object(X) must be a filename pointer that +** has been passed into [sqlite3_vfs].xOpen method where the +** flags parameter to xOpen contains one of the bits +** [SQLITE_OPEN_MAIN_JOURNAL] or [SQLITE_OPEN_WAL]. Any other use +** of this routine results in undefined and probably undesirable +** behavior. +*/ +SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*); + +/* +** CAPI3REF: Create and Destroy VFS Filenames +** +** These interfces are provided for use by [VFS shim] implementations and +** are not useful outside of that context. +** +** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of +** database filename D with corresponding journal file J and WAL file W and +** with N URI parameters key/values pairs in the array P. The result from +** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that +** is safe to pass to routines like: +** +** If a memory allocation error occurs, sqlite3_create_filename() might +** return a NULL pointer. The memory obtained from sqlite3_create_filename(X) +** must be released by a corresponding call to sqlite3_free_filename(Y). +** +** The P parameter in sqlite3_create_filename(D,J,W,N,P) should be an array +** of 2*N pointers to strings. Each pair of pointers in this array corresponds +** to a key and value for a query parameter. The P parameter may be a NULL +** pointer if N is zero. None of the 2*N pointers in the P array may be +** NULL pointers and key pointers should not be empty strings. +** None of the D, J, or W parameters to sqlite3_create_filename(D,J,W,N,P) may +** be NULL pointers, though they can be empty strings. +** +** The sqlite3_free_filename(Y) routine releases a memory allocation +** previously obtained from sqlite3_create_filename(). Invoking +** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op. +** +** If the Y parameter to sqlite3_free_filename(Y) is anything other +** than a NULL pointer or a pointer previously acquired from +** sqlite3_create_filename(), then bad things such as heap +** corruption or segfaults may occur. The value Y should not be +** used again after sqlite3_free_filename(Y) has been called. This means +** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y, +** then the corresponding [sqlite3_module.xClose() method should also be +** invoked prior to calling sqlite3_free_filename(Y). +*/ +SQLITE_API char *sqlite3_create_filename( + const char *zDatabase, + const char *zJournal, + const char *zWal, + int nParam, + const char **azParam +); +SQLITE_API void sqlite3_free_filename(char*); + +/* +** CAPI3REF: Error Codes And Messages +** METHOD: sqlite3 +** +** ^If the most recent sqlite3_* API call associated with +** [database connection] D failed, then the sqlite3_errcode(D) interface +** returns the numeric [result code] or [extended result code] for that +** API call. +** ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** The values returned by sqlite3_errcode() and/or +** sqlite3_extended_errcode() might change with each API call. +** Except, there are some interfaces that are guaranteed to never +** change the value of the error code. The error-code preserving +** interfaces are: +** +** +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db); +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *sqlite3_errmsg(sqlite3*); +SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); + +/* +** CAPI3REF: Prepared Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement that +** has been compiled into binary form and is ready to be evaluated. +** +** Think of each SQL statement as a separate computer program. The +** original SQL text is source code. A prepared statement object +** is the compiled object code. All SQL must be converted into a +** prepared statement before it can be run. +** +** The life-cycle of a prepared statement object usually goes like this: +** +**
    +**
  1. Create the prepared statement object using [sqlite3_prepare_v2()]. +**
  2. Bind values to [parameters] using the sqlite3_bind_*() +** interfaces. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the prepared statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** METHOD: sqlite3 +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
+** [[SQLITE_LIMIT_LENGTH]] ^(
SQLITE_LIMIT_LENGTH
+**
The maximum size of any string or BLOB or table row, in bytes.
)^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
SQLITE_LIMIT_SQL_LENGTH
+**
The maximum length of an SQL statement, in bytes.
)^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
SQLITE_LIMIT_COLUMN
+**
The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
)^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
SQLITE_LIMIT_EXPR_DEPTH
+**
The maximum depth of the parse tree on any expression.
)^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
SQLITE_LIMIT_COMPOUND_SELECT
+**
The maximum number of terms in a compound SELECT statement.
)^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
SQLITE_LIMIT_VDBE_OP
+**
The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. If [sqlite3_prepare_v2()] or +** the equivalent tries to allocate space for more than this many opcodes +** in a single prepared statement, an SQLITE_NOMEM error is returned.
)^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
SQLITE_LIMIT_FUNCTION_ARG
+**
The maximum number of arguments on a function.
)^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
SQLITE_LIMIT_ATTACHED
+**
The maximum number of [ATTACH | attached databases].)^
+** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+**
The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
)^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
+**
The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
SQLITE_LIMIT_TRIGGER_DEPTH
+**
The maximum depth of recursion for triggers.
)^ +** +** [[SQLITE_LIMIT_WORKER_THREADS]] ^(
SQLITE_LIMIT_WORKER_THREADS
+**
The maximum number of auxiliary worker threads that a single +** [prepared statement] may start.
)^ +**
+*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 +#define SQLITE_LIMIT_WORKER_THREADS 11 + +/* +** CAPI3REF: Prepare Flags +** +** These constants define various flags that can be passed into +** "prepFlags" parameter of the [sqlite3_prepare_v3()] and +** [sqlite3_prepare16_v3()] interfaces. +** +** New flags may be added in future releases of SQLite. +** +**
+** [[SQLITE_PREPARE_PERSISTENT]] ^(
SQLITE_PREPARE_PERSISTENT
+**
The SQLITE_PREPARE_PERSISTENT flag is a hint to the query planner +** that the prepared statement will be retained for a long time and +** probably reused many times.)^ ^Without this flag, [sqlite3_prepare_v3()] +** and [sqlite3_prepare16_v3()] assume that the prepared statement will +** be used just once or at most a few times and then destroyed using +** [sqlite3_finalize()] relatively soon. The current implementation acts +** on this hint by avoiding the use of [lookaside memory] so as not to +** deplete the limited store of lookaside memory. Future versions of +** SQLite may act on this hint differently. +** +** [[SQLITE_PREPARE_NORMALIZE]]
SQLITE_PREPARE_NORMALIZE
+**
The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used +** to be required for any prepared statement that wanted to use the +** [sqlite3_normalized_sql()] interface. However, the +** [sqlite3_normalized_sql()] interface is now available to all +** prepared statements, regardless of whether or not they use this +** flag. +** +** [[SQLITE_PREPARE_NO_VTAB]]
SQLITE_PREPARE_NO_VTAB
+**
The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler +** to return an error (error code SQLITE_ERROR) if the statement uses +** any virtual tables. +**
+*/ +#define SQLITE_PREPARE_PERSISTENT 0x01 +#define SQLITE_PREPARE_NORMALIZE 0x02 +#define SQLITE_PREPARE_NO_VTAB 0x04 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_stmt +** +** To execute an SQL statement, it must first be compiled into a byte-code +** program using one of these routines. Or, in other words, these routines +** are constructors for the [prepared statement] object. +** +** The preferred routine to use is [sqlite3_prepare_v2()]. The +** [sqlite3_prepare()] interface is legacy and should be avoided. +** [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used +** for special purposes. +** +** The use of the UTF-8 interfaces is preferred, as SQLite currently +** does all parsing using UTF-8. The UTF-16 interfaces are provided +** as a convenience. The UTF-16 interfaces work by converting the +** input text into UTF-8, then invoking the corresponding UTF-8 interface. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(), +** and sqlite3_prepare_v3() +** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() use UTF-16. +** +** ^If the nByte argument is negative, then zSql is read up to the +** first zero terminator. ^If nByte is positive, then it is the +** number of bytes read from zSql. ^If nByte is zero, then no prepared +** statement is generated. +** If the caller knows that the supplied string is nul-terminated, then +** there is a small performance advantage to passing an nByte parameter that +** is the number of bytes in the input string including +** the nul-terminator. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2(), sqlite3_prepare_v3(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() interfaces are recommended for all new programs. +** The older interfaces (sqlite3_prepare() and sqlite3_prepare16()) +** are retained for backwards compatibility, but their use is discouraged. +** ^In the "vX" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
    +**
  1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY] +** retries will occur before sqlite3_step() gives up and returns an error. +**
    2. +** +**
  2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
    3. +** +**
  3. +** ^If the specific value bound to a [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of a WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled. +**
    4. +**
+** +**

^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having +** the extra prepFlags parameter, which is a bit array consisting of zero or +** more of the [SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_*] flags. ^The +** sqlite3_prepare_v2() interface works exactly the same as +** sqlite3_prepare_v3() with a zero prepFlags parameter. +*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v3( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v3( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** METHOD: sqlite3_stmt +** +** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8 +** SQL text used to create [prepared statement] P if P was +** created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 +** string containing the SQL text of prepared statement P with +** [bound parameters] expanded. +** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8 +** string containing the normalized SQL text of prepared statement P. The +** semantics used to normalize a SQL statement are unspecified and subject +** to change. At a minimum, literal values will be replaced with suitable +** placeholders. +** +** ^(For example, if a prepared statement is created using the SQL +** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345 +** and parameter :xyz is unbound, then sqlite3_sql() will return +** the original string, "SELECT $abc,:xyz" but sqlite3_expanded_sql() +** will return "SELECT 2345,NULL".)^ +** +** ^The sqlite3_expanded_sql() interface returns NULL if insufficient memory +** is available to hold the result, or if the result would exceed the +** the maximum string length determined by the [SQLITE_LIMIT_LENGTH]. +** +** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of +** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time +** option causes sqlite3_expanded_sql() to always return NULL. +** +** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P) +** are managed by SQLite and are automatically freed when the prepared +** statement is finalized. +** ^The string returned by sqlite3_expanded_sql(P), on the other hand, +** is obtained from [sqlite3_malloc()] and must be free by the application +** by passing it to [sqlite3_free()]. +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); +SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); +SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 

+**    SELECT eval('DELETE FROM t1') FROM t2;
+**
+** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +** ^The sqlite3_stmt_readonly() interface returns true for [BEGIN] since +** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and +** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so +** sqlite3_stmt_readonly() returns false for those commands. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the +** prepared statement S is an EXPLAIN statement, or 2 if the +** statement S is an EXPLAIN QUERY PLAN. +** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is +** an ordinary statement or a NULL pointer. +*/ +SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has neither run to completion (returned +** [SQLITE_DONE] from [sqlite3_step(S)]) nor +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. The +** [sqlite3_value_dup()] interface can be used to construct a new +** protected sqlite3_value from an unprotected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used as arguments +** to [sqlite3_result_value()], [sqlite3_bind_value()], and +** [sqlite3_value_dup()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct sqlite3_value sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** METHOD: sqlite3_stmt +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +** +** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 32766). +** +** ^The third argument is the value to bind to the parameter. +** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter +** is ignored and the end result is the same as sqlite3_bind_null(). +** ^If the third parameter to sqlite3_bind_text() is not NULL, then +** it should be a pointer to well-formed UTF8 text. +** ^If the third parameter to sqlite3_bind_text16() is not NULL, then +** it should be a pointer to well-formed UTF16 text. +** ^If the third parameter to sqlite3_bind_text64() is not NULL, then +** it should be a pointer to a well-formed unicode string that is +** either UTF8 if the sixth parameter is SQLITE_UTF8, or UTF16 +** otherwise. +** +** [[byte-order determination rules]] ^The byte-order of +** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF) +** found in first character, which is removed, or in the absence of a BOM +** the byte order is the native byte order of the host +** machine for sqlite3_bind_text16() or the byte order specified in +** the 6th parameter for sqlite3_bind_text64().)^ +** ^If UTF16 input text contains invalid unicode +** characters, then SQLite might change those invalid characters +** into the unicode replacement character: U+FFFD. +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() or sqlite3_bind_text64() then +** that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occurs at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to the BLOB and string binding interfaces +** is a destructor used to dispose of the BLOB or +** string after SQLite has finished with it. ^The destructor is called +** to dispose of the BLOB or string even if the call to the bind API fails, +** except the destructor is not called if the third parameter is a NULL +** pointer or the fourth parameter is negative. +** ^If the fifth argument is +** the special value [SQLITE_STATIC], then SQLite assumes that the +** information is in static, unmanaged space and does not need to be freed. +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. +** +** ^The sixth argument to sqlite3_bind_text64() must be one of +** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] +** to specify the encoding of the text in the third parameter. If +** the sixth argument to sqlite3_bind_text64() is not one of the +** allowed values shown above, or if the text encoding is different +** from the encoding specified by the sixth parameter, then the behavior +** is undefined. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in +** [prepared statement] S to have an SQL value of NULL, but to also be +** associated with the pointer P of type T. ^D is either a NULL pointer or +** a pointer to a destructor function for P. ^SQLite will invoke the +** destructor D with a single argument of P when it is finished using +** P. The T parameter should be a static string, preferably a string +** literal. The sqlite3_bind_pointer() routine is part of the +** [pointer passing interface] added for SQLite 3.20.0. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB +** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or +** [SQLITE_MAX_LENGTH]. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64, + void(*)(void*)); +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*)); +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int sqlite3_bind_pointer(sqlite3_stmt*, int, void*, const char*,void(*)(void*)); +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); +SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64); + +/* +** CAPI3REF: Number Of SQL Parameters +** METHOD: sqlite3_stmt +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** METHOD: sqlite3_stmt +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** METHOD: sqlite3_stmt +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or +** [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_name()]. +*/ +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** METHOD: sqlite3_stmt +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^If this routine returns 0, that means the +** [prepared statement] returns no data (for example an [UPDATE]). +** ^However, just because this routine returns a positive number does not +** mean that one or more rows of data will be returned. ^A SELECT statement +** will always have a positive sqlite3_column_count() but depending on the +** WHERE clause constraints and the table content, it might return no rows. +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** METHOD: sqlite3_stmt +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** METHOD: sqlite3_stmt +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routines might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** METHOD: sqlite3_stmt +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** METHOD: sqlite3_stmt +** +** After a [prepared statement] has been prepared using any of +** [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], +** or [sqlite3_prepare16_v3()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "vX" interfaces +** [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()], +** [sqlite3_prepare16_v2()] or the older legacy +** interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "vX" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after [version 3.6.23.1] ([dateof:3.6.23.1], +** sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()] +** or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "vX" interfaces is recommended. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** METHOD: sqlite3_stmt +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column()] family of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +** )^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** METHOD: sqlite3_stmt +** +** Summary: +**
+**
sqlite3_column_blob→BLOB result +**
sqlite3_column_double→REAL result +**
sqlite3_column_int→32-bit INTEGER result +**
sqlite3_column_int64→64-bit INTEGER result +**
sqlite3_column_text→UTF-8 TEXT result +**
sqlite3_column_text16→UTF-16 TEXT result +**
sqlite3_column_value→The result as an +** [sqlite3_value|unprotected sqlite3_value] object. +**
    +**
sqlite3_column_bytes→Size of a BLOB +** or a UTF-8 TEXT result in bytes +**
sqlite3_column_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
sqlite3_column_type→Default +** datatype of the result +**
+** +** Details: +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** The first six interfaces (_blob, _double, _int, _int64, _text, and _text16) +** each return the value of a result column in a specific data format. If +** the result column is not initially in the requested format (for example, +** if the query returns an integer but the sqlite3_column_text() interface +** is used to extract the value) then an automatic type conversion is performed. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. +** The return value of sqlite3_column_type() can be used to decide which +** of the first six interface should be used to extract the column value. +** The value returned by sqlite3_column_type() is only meaningful if no +** automatic type conversions have occurred for the value in question. +** After a type conversion, the result of calling sqlite3_column_type() +** is undefined, though harmless. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes() +** or sqlite3_column_bytes16() interfaces can be used to determine the size +** of that BLOB or string. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** Warning: ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. In a multithreaded environment, +** an unprotected sqlite3_value object may only be used safely with +** [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], the behavior is not threadsafe. +** Hence, the sqlite3_column_value() interface +** is normally only useful within the implementation of +** [application-defined SQL functions] or [virtual tables], not within +** top-level application code. +** +** The these routines may attempt to convert the datatype of the result. +** ^For example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
+** +**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is a NULL pointer +**
NULL BLOB Result is a NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as INTEGER->TEXT +**
FLOAT INTEGER [CAST] to INTEGER +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB [CAST] to BLOB +**
TEXT INTEGER [CAST] to INTEGER +**
TEXT FLOAT [CAST] to REAL +**
TEXT BLOB No change +**
BLOB INTEGER [CAST] to INTEGER +**
BLOB FLOAT [CAST] to REAL +**
BLOB TEXT Add a zero terminator if needed +**
+**
)^ +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +** +** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest policy is to invoke these routines +** in one of the following ways: +** +** +** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** As long as the input parameters are correct, these routines will only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +** +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** DESTRUCTOR: sqlite3_stmt +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** METHOD: sqlite3_stmt +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** METHOD: sqlite3 +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** the three "sqlite3_create_function*" routines are the text encoding +** expected for the second parameter (the name of the function being +** created) and the presence or absence of a destructor callback for +** the application data pointer. Function sqlite3_create_window_function() +** is similar, but allows the user to supply the extra callback functions +** needed by [aggregate window functions]. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. The application should set this parameter to +** [SQLITE_UTF16LE] if the function implementation invokes +** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the +** implementation invokes [sqlite3_value_text16be()] on an input, or +** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8] +** otherwise. ^The same SQL function may be registered multiple times using +** different preferred text encodings, with different implementations for +** each encoding. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** +** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC] +** to signal that the function will always return the same result given +** the same inputs within a single SQL statement. Most SQL functions are +** deterministic. The built-in [random()] SQL function is an example of a +** function that is not deterministic. The SQLite query planner is able to +** perform additional optimizations on deterministic functions, so use +** of the [SQLITE_DETERMINISTIC] flag is recommended where possible. +** +** ^The fourth parameter may also optionally include the [SQLITE_DIRECTONLY] +** flag, which if present prevents the function from being invoked from +** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions, +** index expressions, or the WHERE clause of partial indexes. +** +** +** For best security, the [SQLITE_DIRECTONLY] flag is recommended for +** all application-defined SQL functions that do not need to be +** used inside of triggers, view, CHECK constraints, or other elements of +** the database schema. This flags is especially recommended for SQL +** functions that have side effects or reveal internal application state. +** Without this flag, an attacker might be able to modify the schema of +** a database file to include invocations of the function with parameters +** chosen by the attacker, which the application will then execute when +** the database file is opened and read. +** +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters passed to the three +** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue +** and xInverse) passed to sqlite3_create_window_function are pointers to +** C-language callbacks that implement the new function. xStep and xFinal +** must both be non-NULL. xValue and xInverse may either both be NULL, in +** which case a regular aggregate function is created, or must both be +** non-NULL, in which case the new function may be used as either an aggregate +** or aggregate window function. More details regarding the implementation +** of aggregate window functions are +** [user-defined window functions|available here]. +** +** ^(If the final parameter to sqlite3_create_function_v2() or +** sqlite3_create_window_function() is not NULL, then it is destructor for +** the application data pointer. The destructor is invoked when the function +** is deleted, either by being overloaded or when the database connection +** closes.)^ ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. ^When the destructor callback is +** invoked, it is passed a single argument which is a copy of the application +** data pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_window_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */ +#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */ +#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */ +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* Deprecated */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Function Flags +** +** These constants may be ORed together with the +** [SQLITE_UTF8 | preferred text encoding] as the fourth argument +** to [sqlite3_create_function()], [sqlite3_create_function16()], or +** [sqlite3_create_function_v2()]. +** +**
+** [[SQLITE_DETERMINISTIC]]
SQLITE_DETERMINISTIC
+** The SQLITE_DETERMINISTIC flag means that the new function always gives +** the same output when the input parameters are the same. +** The [abs|abs() function] is deterministic, for example, but +** [randomblob|randomblob()] is not. Functions must +** be deterministic in order to be used in certain contexts such as +** with the WHERE clause of [partial indexes] or in [generated columns]. +** SQLite might also optimize deterministic functions by factoring them +** out of inner loops. +**
+** +** [[SQLITE_DIRECTONLY]]
SQLITE_DIRECTONLY
+** The SQLITE_DIRECTONLY flag means that the function may only be invoked +** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], or [generated columns]. +** The SQLITE_DIRECTONLY flags is a security feature which is recommended +** for all [application-defined SQL functions], and especially for functions +** that have side-effects or that could potentially leak sensitive +** information. +**
+** +** [[SQLITE_INNOCUOUS]]
SQLITE_INNOCUOUS
+** The SQLITE_INNOCUOUS flag means that the function is unlikely +** to cause problems even if misused. An innocuous function should have +** no side effects and should not depend on any values other than its +** input parameters. The [abs|abs() function] is an example of an +** innocuous function. +** The [load_extension() SQL function] is not innocuous because of its +** side effects. +**

SQLITE_INNOCUOUS is similar to SQLITE_DETERMINISTIC, but is not +** exactly the same. The [random|random() function] is an example of a +** function that is innocuous but not deterministic. +**

Some heightened security settings +** ([SQLITE_DBCONFIG_TRUSTED_SCHEMA] and [PRAGMA trusted_schema=OFF]) +** disable the use of SQL functions inside views and triggers and in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], and [generated columns] unless +** the function is tagged with SQLITE_INNOCUOUS. Most built-in functions +** are innocuous. Developers are advised to avoid using the +** SQLITE_INNOCUOUS flag for application-defined functions unless the +** function has been carefully audited and found to be free of potentially +** security-adverse side-effects and information-leaks. +**

+** +** [[SQLITE_SUBTYPE]]
SQLITE_SUBTYPE
+** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call +** [sqlite3_value_subtype()] to inspect the sub-types of its arguments. +** Specifying this flag makes no difference for scalar or aggregate user +** functions. However, if it is not specified for a user-defined window +** function, then any sub-types belonging to arguments passed to the window +** function may be discarded before the window function is called (i.e. +** sqlite3_value_subtype() will always return 0). +**
+**
+*/ +#define SQLITE_DETERMINISTIC 0x000000800 +#define SQLITE_DIRECTONLY 0x000080000 +#define SQLITE_SUBTYPE 0x000100000 +#define SQLITE_INNOCUOUS 0x000200000 + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To encourage programmers to avoid +** these functions, we will not explain what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Values +** METHOD: sqlite3_value +** +** Summary: +**
+**
sqlite3_value_blob→BLOB value +**
sqlite3_value_double→REAL value +**
sqlite3_value_int→32-bit INTEGER value +**
sqlite3_value_int64→64-bit INTEGER value +**
sqlite3_value_pointer→Pointer value +**
sqlite3_value_text→UTF-8 TEXT value +**
sqlite3_value_text16→UTF-16 TEXT value in +** the native byteorder +**
sqlite3_value_text16be→UTF-16be TEXT value +**
sqlite3_value_text16le→UTF-16le TEXT value +**
    +**
sqlite3_value_bytes→Size of a BLOB +** or a UTF-8 TEXT in bytes +**
sqlite3_value_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
sqlite3_value_type→Default +** datatype of the value +**
sqlite3_value_numeric_type   +** →  Best numeric datatype of the value +**
sqlite3_value_nochange   +** →  True if the column is unchanged in an UPDATE +** against a virtual table. +**
sqlite3_value_frombind   +** →  True if value originated from a [bound parameter] +**
+** +** Details: +** +** These routines extract type, size, and content information from +** [protected sqlite3_value] objects. Protected sqlite3_value objects +** are used to pass parameter information into the functions that +** implement [application-defined SQL functions] and [virtual tables]. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** is not threadsafe. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^If [sqlite3_value] object V was initialized +** using [sqlite3_bind_pointer(S,I,P,X,D)] or [sqlite3_result_pointer(C,P,X,D)] +** and if X and Y are strings that compare equal according to strcmp(X,Y), +** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise, +** sqlite3_value_pointer(V,Y) returns a NULL. The sqlite3_bind_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** ^(The sqlite3_value_type(V) interface returns the +** [SQLITE_INTEGER | datatype code] for the initial datatype of the +** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].)^ +** Other interfaces might change the datatype for an sqlite3_value object. +** For example, if the datatype is initially SQLITE_INTEGER and +** sqlite3_value_text(V) is called to extract a text value for that +** integer, then subsequent calls to sqlite3_value_type(V) might return +** SQLITE_TEXT. Whether or not a persistent internal datatype conversion +** occurs is undefined and may change from one release of SQLite to the next. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** ^Within the [xUpdate] method of a [virtual table], the +** sqlite3_value_nochange(X) interface returns true if and only if +** the column corresponding to X is unchanged by the UPDATE operation +** that the xUpdate method call was invoked to implement and if +** and the prior [xColumn] method call that was invoked to extracted +** the value for that column returned without setting a result (probably +** because it queried [sqlite3_vtab_nochange()] and found that the column +** was unchanging). ^Within an [xUpdate] method, any value for which +** sqlite3_value_nochange(X) is true will in all other respects appear +** to be a NULL value. If sqlite3_value_nochange(X) is invoked anywhere other +** than within an [xUpdate] method call for an UPDATE statement, then +** the return value is arbitrary and meaningless. +** +** ^The sqlite3_value_frombind(X) interface returns non-zero if the +** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()] +** interfaces. ^If X comes from an SQL literal value, or a table column, +** or an expression, then sqlite3_value_frombind(X) returns zero. +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +** +** As long as the input parameter is correct, these routines can only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +** +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); +SQLITE_API double sqlite3_value_double(sqlite3_value*); +SQLITE_API int sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +SQLITE_API void *sqlite3_value_pointer(sqlite3_value*, const char*); +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API int sqlite3_value_type(sqlite3_value*); +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); +SQLITE_API int sqlite3_value_nochange(sqlite3_value*); +SQLITE_API int sqlite3_value_frombind(sqlite3_value*); + +/* +** CAPI3REF: Finding The Subtype Of SQL Values +** METHOD: sqlite3_value +** +** The sqlite3_value_subtype(V) function returns the subtype for +** an [application-defined SQL function] argument V. The subtype +** information can be used to pass a limited amount of context from +** one SQL function to another. Use the [sqlite3_result_subtype()] +** routine to set the subtype for the return value of an SQL function. +*/ +SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*); + +/* +** CAPI3REF: Copy And Free SQL Values +** METHOD: sqlite3_value +** +** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value] +** object D and returns a pointer to that copy. ^The [sqlite3_value] returned +** is a [protected sqlite3_value] object even if the input is not. +** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a +** memory allocation fails. +** +** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object +** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer +** then sqlite3_value_free(V) is a harmless no-op. +*/ +SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value*); +SQLITE_API void sqlite3_value_free(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** METHOD: sqlite3_context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite allocates +** N bytes of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocate error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in any subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** METHOD: sqlite3_context +** +** These functions may be used by (non-aggregate) SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. An example +** of where this might be useful is in a regular-expression matching +** function. The compiled version of the regular expression can be stored as +** metadata associated with the pattern string. +** Then as long as the pattern string remains the same, +** the compiled regular expression can be reused on multiple +** invocations of the same function. +** +** ^The sqlite3_get_auxdata(C,N) interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata(C,N,P,X) function with the Nth argument +** value to the application-defined function. ^N is zero for the left-most +** function argument. ^If there is no metadata +** associated with the function argument, the sqlite3_get_auxdata(C,N) interface +** returns a NULL pointer. +** +** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th +** argument of the application-defined function. ^Subsequent +** calls to sqlite3_get_auxdata(C,N) return P from the most recent +** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or +** NULL if the metadata has been discarded. +** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL, +** SQLite will invoke the destructor function X with parameter P exactly +** once, when the metadata is discarded. +** SQLite is free to discard the metadata at any time, including: +** +** Note the last bullet in particular. The destructor X in +** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the +** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata() +** should be called near the end of the function implementation and the +** function implementation should not make any use of P after +** sqlite3_set_auxdata() has been called. +** +** ^(In practice, metadata is preserved between function calls for +** function parameters that are compile-time constants, including literal +** values and [parameters] and expressions composed from the same.)^ +** +** The value of the N parameter to these interfaces should be non-negative. +** Future enhancements may make use of negative N values to define new +** kinds of function caching behavior. +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** METHOD: sqlite3_context +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N) +** interfaces set the result of the application-defined function to be +** a BLOB containing all zero bytes and N bytes in size. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 using +** the same [byte-order determination rules] as [sqlite3_bind_text16()]. +** ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^The sqlite3_result_text64() interface sets the return value of an +** application-defined function to be a text string in an encoding +** specified by the fifth (and last) parameter, which must be one +** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained +** from [sqlite3_malloc()] before it returns. +** +** ^For the sqlite3_result_text16(), sqlite3_result_text16le(), and +** sqlite3_result_text16be() routines, and for sqlite3_result_text64() +** when the encoding is not UTF8, if the input UTF16 begins with a +** byte-order mark (BOM, U+FEFF) then the BOM is removed from the +** string and the rest of the string is interpreted according to the +** byte-order specified by the BOM. ^The byte-order specified by +** the BOM at the beginning of the text overrides the byte-order +** specified by the interface procedure. ^So, for example, if +** sqlite3_result_text16le() is invoked with text that begins +** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the +** first two bytes of input are skipped and the remaining input +** is interpreted as UTF16BE text. +** +** ^For UTF16 input text to the sqlite3_result_text16(), +** sqlite3_result_text16be(), sqlite3_result_text16le(), and +** sqlite3_result_text64() routines, if the text contains invalid +** UTF16 characters, the invalid characters might be converted +** into the unicode replacement character, U+FFFD. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy of the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** ^The sqlite3_result_pointer(C,P,T,D) interface sets the result to an +** SQL NULL value, just like [sqlite3_result_null(C)], except that it +** also associates the host-language pointer P or type T with that +** NULL value such that the pointer can be retrieved within an +** [application-defined SQL function] using [sqlite3_value_pointer()]. +** ^If the D parameter is not NULL, then it is a pointer to a destructor +** for the P parameter. ^SQLite invokes D with P as its only argument +** when SQLite is finished with P. The T parameter should be a static +** string and preferably a string literal. The sqlite3_result_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*, + sqlite3_uint64,void(*)(void*)); +SQLITE_API void sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void sqlite3_result_null(sqlite3_context*); +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void sqlite3_result_pointer(sqlite3_context*, void*,const char*,void(*)(void*)); +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); +SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n); + + +/* +** CAPI3REF: Setting The Subtype Of An SQL Function +** METHOD: sqlite3_context +** +** The sqlite3_result_subtype(C,T) function causes the subtype of +** the result from the [application-defined SQL function] with +** [sqlite3_context] C to be the value T. Only the lower 8 bits +** of the subtype T are preserved in current versions of SQLite; +** higher order bits are discarded. +** The number of subtype bytes preserved by SQLite might increase +** in future releases of SQLite. +*/ +SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int); + +/* +** CAPI3REF: Define New Collating Sequences +** METHOD: sqlite3 +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +** )^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCompare. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCompare, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCompare argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The two integer parameters to the collating +** function callback are the length of the two strings, in bytes. The collating +** function must return an integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
    +**
  1. If A==B then B==A. +**
  2. If A==B and B==C then A==C. +**
  3. If A<B THEN B>A. +**
  4. If A<B and B<C then A<C. +**
+** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** METHOD: sqlite3 +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +*/ +SQLITE_API int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** Applications are strongly discouraged from using this global variable. +** It is required to set a temporary folder on Windows Runtime (WinRT). +** But for all other platforms, it is highly recommended that applications +** neither read nor write this variable. This global variable is a relic +** that exists for backwards compatibility of legacy applications and should +** be avoided in new projects. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** Except when requested by the [temp_store_directory pragma], SQLite +** does not free the memory that sqlite3_temp_directory points to. If +** the application wants that memory to be freed, it must do +** so itself, taking care to only do so after all [database connection] +** objects have been destroyed. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
+** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
+*/ +SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory; + +/* +** CAPI3REF: Win32 Specific Interface +** +** These interfaces are available only on Windows. The +** [sqlite3_win32_set_directory] interface is used to set the value associated +** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to +** zValue, depending on the value of the type parameter. The zValue parameter +** should be NULL to cause the previous value to be freed via [sqlite3_free]; +** a non-NULL value will be copied into memory obtained from [sqlite3_malloc] +** prior to being used. The [sqlite3_win32_set_directory] interface returns +** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported, +** or [SQLITE_NOMEM] if memory could not be allocated. The value of the +** [sqlite3_data_directory] variable is intended to act as a replacement for +** the current directory on the sub-platforms of Win32 where that concept is +** not present, e.g. WinRT and UWP. The [sqlite3_win32_set_directory8] and +** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the +** sqlite3_win32_set_directory interface except the string parameter must be +** UTF-8 or UTF-16, respectively. +*/ +SQLITE_API int sqlite3_win32_set_directory( + unsigned long type, /* Identifier for directory being set or reset */ + void *zValue /* New value for directory being set or reset */ +); +SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue); +SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue); + +/* +** CAPI3REF: Win32 Directory Types +** +** These macros are only available on Windows. They define the allowed values +** for the type argument to the [sqlite3_win32_set_directory] interface. +*/ +#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1 +#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2 + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** METHOD: sqlite3 +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to the filename +** associated with database N of connection D. +** ^If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** this function will return either a NULL pointer or an empty string. +** +** ^The string value returned by this routine is owned and managed by +** the database connection. ^The value will be valid until the database N +** is [DETACH]-ed or until the database connection closes. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +** +** If the filename pointer returned by this routine is not NULL, then it +** can be used as the filename input parameter to these routines: +** +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** METHOD: sqlite3 +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine the transaction state of a database +** METHOD: sqlite3 +** +** ^The sqlite3_txn_state(D,S) interface returns the current +** [transaction state] of schema S in database connection D. ^If S is NULL, +** then the highest transaction state of any schema on database connection D +** is returned. Transaction states are (in order of lowest to highest): +**
    +**
  1. SQLITE_TXN_NONE +**
  2. SQLITE_TXN_READ +**
  3. SQLITE_TXN_WRITE +**
+** ^If the S argument to sqlite3_txn_state(D,S) is not the name of +** a valid schema, then -1 is returned. +*/ +SQLITE_API int sqlite3_txn_state(sqlite3*,const char *zSchema); + +/* +** CAPI3REF: Allowed return values from [sqlite3_txn_state()] +** KEYWORDS: {transaction state} +** +** These constants define the current transaction state of a database file. +** ^The [sqlite3_txn_state(D,S)] interface returns one of these +** constants in order to describe the transaction state of schema S +** in [database connection] D. +** +**
+** [[SQLITE_TXN_NONE]]
SQLITE_TXN_NONE
+**
The SQLITE_TXN_NONE state means that no transaction is currently +** pending.
+** +** [[SQLITE_TXN_READ]]
SQLITE_TXN_READ
+**
The SQLITE_TXN_READ state means that the database is currently +** in a read transaction. Content has been read from the database file +** but nothing in the database file has changed. The transaction state +** will advanced to SQLITE_TXN_WRITE if any changes occur and there are +** no other conflicting concurrent write transactions. The transaction +** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or +** [COMMIT].
+** +** [[SQLITE_TXN_WRITE]]
SQLITE_TXN_WRITE
+**
The SQLITE_TXN_WRITE state means that the database is currently +** in a write transaction. Content has been written to the database file +** but has not yet committed. The transaction state will change to +** to SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].
+*/ +#define SQLITE_TXN_NONE 0 +#define SQLITE_TXN_READ 1 +#define SQLITE_TXN_WRITE 2 + +/* +** CAPI3REF: Find the next prepared statement +** METHOD: sqlite3 +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted in +** a [rowid table]. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted in a rowid table. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_sequence).)^ +** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified. +** +** ^In the current implementation, the update hook +** is not invoked when conflicting rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()], [sqlite3_rollback_hook()], +** and [sqlite3_preupdate_hook()] interfaces. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite [version 3.5.0] ([dateof:3.5.0]). +** In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue to use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. It is recommended that it stay +** that way. In other words, do not use this routine. This interface +** continues to be provided for historical compatibility, but its use is +** discouraged. Any use of shared cache is discouraged. If shared cache +** must be used, it is recommended that shared cache only be enabled for +** individual database connections using the [sqlite3_open_v2()] interface +** with the [SQLITE_OPEN_SHAREDCACHE] flag. +** +** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0 +** and will always return SQLITE_MISUSE. On those systems, +** shared cache mode should be enabled per-database connection via +** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE]. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is in effect even +** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** These interfaces impose limits on the amount of heap memory that will be +** by all database connections within a single process. +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The sqlite3_hard_heap_limit64(N) interface sets a hard upper bound of +** N bytes on the amount of memory that will be allocated. ^The +** sqlite3_hard_heap_limit64(N) interface is similar to +** sqlite3_soft_heap_limit64(N) except that memory allocations will fail +** when the hard heap limit is reached. +** +** ^The return value from both sqlite3_soft_heap_limit64() and +** sqlite3_hard_heap_limit64() is the size of +** the heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the heap limit. Hence, the current +** size of heap limits can be determined by invoking +** sqlite3_soft_heap_limit64(-1) or sqlite3_hard_heap_limit(-1). +** +** ^Setting the heap limits to zero disables the heap limiter mechanism. +** +** ^The soft heap limit may not be greater than the hard heap limit. +** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N) +** is invoked with a value of N that is greater than the hard heap limit, +** the the soft heap limit is set to the value of the hard heap limit. +** ^The soft heap limit is automatically enabled whenever the hard heap +** limit is enabled. ^When sqlite3_hard_heap_limit64(N) is invoked and +** the soft heap limit is outside the range of 1..N, then the soft heap +** limit is set to N. ^Invoking sqlite3_soft_heap_limit64(0) when the +** hard heap limit is enabled makes the soft heap limit equal to the +** hard heap limit. +** +** The memory allocation limits can also be adjusted using +** [PRAGMA soft_heap_limit] and [PRAGMA hard_heap_limit]. +** +** ^(The heap limits are not enforced in the current implementation +** if one or more of following conditions are true: +** +**
    +**
  • The limit value is set to zero. +**
  • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
  • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
  • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
)^ +** +** The circumstances under which SQLite will enforce the heap limits may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N); +SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** METHOD: sqlite3 +** +** ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns +** information about column C of table T in database D +** on [database connection] X.)^ ^The sqlite3_table_column_metadata() +** interface returns SQLITE_OK and fills in the non-NULL pointers in +** the final five arguments with appropriate values if the specified +** column exists. ^The sqlite3_table_column_metadata() interface returns +** SQLITE_ERROR if the specified column does not exist. +** ^If the column-name parameter to sqlite3_table_column_metadata() is a +** NULL pointer, then this routine simply checks for the existence of the +** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it +** does not. If the table name parameter T in a call to +** sqlite3_table_column_metadata(X,D,T,C,...) is NULL then the result is +** undefined behavior. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^(The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL.)^ ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
+** +**
Parameter Output
Type 		Description +** +**
5th const char* Data type +**
6th const char* Name of default collation sequence +**
7th int True if column has a NOT NULL constraint +**
8th int True if column is part of the PRIMARY KEY +**
9th int True if column is [AUTOINCREMENT] +**
+**
)^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and the table +** is not a [WITHOUT ROWID] table and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** [INTEGER PRIMARY KEY] column, then the outputs +** for the [rowid] are set as follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
)^ +** +** ^This function causes all database schemas to be read from disk and +** parsed, if that has not already been done, and returns an error if +** any errors are encountered while loading the schema. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** METHOD: sqlite3 +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** [SQLite extension] library contained in the file zFile. If +** the file cannot be loaded directly, attempts are made to load +** with various operating-system specific extensions added. +** So for example, if "samplelib" cannot be loaded, then names like +** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might +** be tried also. +** +** ^The entry point is zProc. +** ^(zProc may be 0, in which case SQLite will try to come up with an +** entry point name on its own. It first tries "sqlite3_extension_init". +** If that does not work, it constructs a name "sqlite3_X_init" where the +** X is consists of the lower-case equivalent of all ASCII alphabetic +** characters in the filename from the last "/" to the first following +** "." and omitting any initial "lib".)^ +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] or +** [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],1,NULL) +** prior to calling this API, +** otherwise an error will be returned. +** +** Security warning: It is recommended that the +** [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method be used to enable only this +** interface. The use of the [sqlite3_enable_load_extension()] interface +** should be avoided. This will keep the SQL function [load_extension()] +** disabled and prevent SQL injections from giving attackers +** access to extension loading capabilities. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** METHOD: sqlite3 +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with [extension loading], and as a means of disabling +** [extension loading] while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +** +** ^This interface enables or disables both the C-API +** [sqlite3_load_extension()] and the SQL function [load_extension()]. +** ^(Use [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],..) +** to enable or disable only the C-API.)^ +** +** Security warning: It is recommended that extension loading +** be enabled using the [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method +** rather than this interface, so the [load_extension()] SQL function +** remains disabled. This will prevent SQL injections from giving attackers +** access to extension loading capabilities. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked [SQLite extension] +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects an integer result as if the signature of the +** entry point where as follows: +** +** 
+**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
)^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()] +** and [sqlite3_cancel_auto_extension()] +*/ +SQLITE_API int sqlite3_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Cancel Automatic Extension Loading +** +** ^The [sqlite3_cancel_auto_extension(X)] interface unregisters the +** initialization routine X that was registered using a prior call to +** [sqlite3_auto_extension(X)]. ^The [sqlite3_cancel_auto_extension(X)] +** routine returns 1 if initialization routine X was successfully +** unregistered and it returns 0 if X was not on the list of initialization +** routines. +*/ +SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void); + +/* +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual table]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); + /* The methods above are in versions 1 and 2 of the sqlite_module object. + ** Those below are for version 3 and greater. */ + int (*xShadowName)(const char*); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
column OP expr
+** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The colUsed field indicates which columns of the virtual table may be +** required by the current scan. Virtual table columns are numbered from +** zero in the order in which they appear within the CREATE TABLE statement +** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +** the corresponding bit is set within the colUsed mask if the column may be +** required by SQLite. If the table has at least 64 columns and any column +** to the right of the first 63 is required, then bit 63 of colUsed is also +** set. In other words, column iCol may be required if the expression +** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +** non-zero. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and might not be checked again by the byte code.)^ ^(The +** aConstraintUsage[].omit flag is an optimization hint. When the omit flag +** is left in its default setting of false, the constraint will always be +** checked separately in byte code. If the omit flag is change to true, then +** the constraint may or may not be checked in byte code. In other words, +** when the omit flag is true there is no guarantee that the constraint will +** not be checked again using byte code.)^ +** +** ^The idxNum and idxPtr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxPtr if and only if +** needToFreeIdxPtr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of a particular +** strategy. A cost of N indicates that the cost of the strategy is similar +** to a linear scan of an SQLite table with N rows. A cost of log(N) +** indicates that the expense of the operation is similar to that of a +** binary search on a unique indexed field of an SQLite table with N rows. +** +** ^The estimatedRows value is an estimate of the number of rows that +** will be returned by the strategy. +** +** The xBestIndex method may optionally populate the idxFlags field with a +** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +** assumes that the strategy may visit at most one row. +** +** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +** SQLite also assumes that if a call to the xUpdate() method is made as +** part of the same statement to delete or update a virtual table row and the +** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +** any database changes. In other words, if the xUpdate() returns +** SQLITE_CONSTRAINT, the database contents must be exactly as they were +** before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +** the xUpdate method are automatically rolled back by SQLite. +** +** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +** structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +** If a virtual table extension is +** used with an SQLite version earlier than 3.8.2, the results of attempting +** to read or write the estimatedRows field are undefined (but are likely +** to include crashing the application). The estimatedRows field should +** therefore only be used if [sqlite3_libversion_number()] returns a +** value greater than or equal to 3008002. Similarly, the idxFlags field +** was added for [version 3.9.0] ([dateof:3.9.0]). +** It may therefore only be used if +** sqlite3_libversion_number() returns a value greater than or equal to +** 3009000. +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column constrained. -1 for ROWID */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ + /* Fields below are only available in SQLite 3.8.2 and later */ + sqlite3_int64 estimatedRows; /* Estimated number of rows returned */ + /* Fields below are only available in SQLite 3.9.0 and later */ + int idxFlags; /* Mask of SQLITE_INDEX_SCAN_* flags */ + /* Fields below are only available in SQLite 3.10.0 and later */ + sqlite3_uint64 colUsed; /* Input: Mask of columns used by statement */ +}; + +/* +** CAPI3REF: Virtual Table Scan Flags +** +** Virtual table implementations are allowed to set the +** [sqlite3_index_info].idxFlags field to some combination of +** these bits. +*/ +#define SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */ + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros define the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the wHERE clause of +** a query that uses a [virtual table]. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 +#define SQLITE_INDEX_CONSTRAINT_LIKE 65 +#define SQLITE_INDEX_CONSTRAINT_GLOB 66 +#define SQLITE_INDEX_CONSTRAINT_REGEXP 67 +#define SQLITE_INDEX_CONSTRAINT_NE 68 +#define SQLITE_INDEX_CONSTRAINT_ISNOT 69 +#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70 +#define SQLITE_INDEX_CONSTRAINT_ISNULL 71 +#define SQLITE_INDEX_CONSTRAINT_IS 72 +#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** METHOD: sqlite3 +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +** +** ^If the third parameter (the pointer to the sqlite3_module object) is +** NULL then no new module is create and any existing modules with the +** same name are dropped. +** +** See also: [sqlite3_drop_modules()] +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Remove Unnecessary Virtual Table Implementations +** METHOD: sqlite3 +** +** ^The sqlite3_drop_modules(D,L) interface removes all virtual +** table modules from database connection D except those named on list L. +** The L parameter must be either NULL or a pointer to an array of pointers +** to strings where the array is terminated by a single NULL pointer. +** ^If the L parameter is NULL, then all virtual table modules are removed. +** +** See also: [sqlite3_create_module()] +*/ +SQLITE_API int sqlite3_drop_modules( + sqlite3 *db, /* Remove modules from this connection */ + const char **azKeep /* Except, do not remove the ones named here */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Number of open cursors */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** METHOD: sqlite3 +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB +** KEYWORDS: {BLOB handle} {BLOB handles} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_blob +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
)^ +** +** ^(Parameter zDb is not the filename that contains the database, but +** rather the symbolic name of the database. For attached databases, this is +** the name that appears after the AS keyword in the [ATTACH] statement. +** For the main database file, the database name is "main". For TEMP +** tables, the database name is "temp".)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If the flags parameter is zero, the BLOB is opened for +** read-only access. +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored +** in *ppBlob. Otherwise an [error code] is returned and, unless the error +** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided +** the API is not misused, it is always safe to call [sqlite3_blob_close()] +** on *ppBlob after this function it returns. +** +** This function fails with SQLITE_ERROR if any of the following are true: +**
    +**
  • ^(Database zDb does not exist)^, +**
  • ^(Table zTable does not exist within database zDb)^, +**
  • ^(Table zTable is a WITHOUT ROWID table)^, +**
  • ^(Column zColumn does not exist)^, +**
  • ^(Row iRow is not present in the table)^, +**
  • ^(The specified column of row iRow contains a value that is not +** a TEXT or BLOB value)^, +**
  • ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE +** constraint and the blob is being opened for read/write access)^, +**
  • ^([foreign key constraints | Foreign key constraints] are enabled, +** column zColumn is part of a [child key] definition and the blob is +** being opened for read/write access)^. +**
+** +** ^Unless it returns SQLITE_MISUSE, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** A BLOB referenced by sqlite3_blob_open() may be read using the +** [sqlite3_blob_read()] interface and modified by using +** [sqlite3_blob_write()]. The [BLOB handle] can be moved to a +** different row of the same table using the [sqlite3_blob_reopen()] +** interface. However, the column, table, or database of a [BLOB handle] +** cannot be changed after the [BLOB handle] is opened. +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function may be used to create a +** zero-filled blob to read or write using the incremental-blob interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +** +** See also: [sqlite3_blob_close()], +** [sqlite3_blob_reopen()], [sqlite3_blob_read()], +** [sqlite3_blob_bytes()], [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** METHOD: sqlite3_blob +** +** ^This function is used to move an existing [BLOB handle] so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing [BLOB handle] to a new row is +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** DESTRUCTOR: sqlite3_blob +** +** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed +** unconditionally. Even if this routine returns an error code, the +** handle is still closed.)^ +** +** ^If the blob handle being closed was opened for read-write access, and if +** the database is in auto-commit mode and there are no other open read-write +** blob handles or active write statements, the current transaction is +** committed. ^If an error occurs while committing the transaction, an error +** code is returned and the transaction rolled back. +** +** Calling this function with an argument that is not a NULL pointer or an +** open blob handle results in undefined behaviour. ^Calling this routine +** with a null pointer (such as would be returned by a failed call to +** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function +** is passed a valid open blob handle, the values returned by the +** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning. +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** METHOD: sqlite3_blob +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset.)^ +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** ^Unless SQLITE_MISUSE is returned, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. The size of the +** BLOB (and hence the maximum value of N+iOffset) can be determined +** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less +** than zero [SQLITE_ERROR] is returned and no data is written. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_PTHREADS +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
+** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize(). +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc() +** routine returns NULL if it is unable to allocate the requested +** mutex. The argument to sqlite3_mutex_alloc() must one of these +** integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MAIN +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +**
+** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Nine static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^For the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. Attempting to deallocate a static +** mutex results in undefined behavior. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases, the +** mutex must be exited an equal number of times before another thread +** can enter.)^ If the same thread tries to enter any mutex other +** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined. +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable +** behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or +** sqlite3_mutex_leave() is a NULL pointer, then all three routines +** behave as no-ops. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the application has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the application +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
    +**
  • [sqlite3_mutex_alloc()]
    • +**
  • [sqlite3_mutex_free()]
    • +**
  • [sqlite3_mutex_enter()]
    • +**
  • [sqlite3_mutex_try()]
    • +**
  • [sqlite3_mutex_leave()]
    • +**
  • [sqlite3_mutex_held()]
    • +**
  • [sqlite3_mutex_notheld()]
    • +**
)^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case. The results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MAIN 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ +#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */ +#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */ +#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */ +#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */ + +/* Legacy compatibility: */ +#define SQLITE_MUTEX_STATIC_MASTER 2 + + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** METHOD: sqlite3 +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** METHOD: sqlite3 +** KEYWORDS: {file control} +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** A few opcodes for [sqlite3_file_control()] are handled directly +** by the SQLite core and never invoke the +** sqlite3_io_methods.xFileControl method. +** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. The +** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns +** the [sqlite3_file] object associated with the journal file instead of +** the main database. The [SQLITE_FCNTL_VFS_POINTER] opcode returns +** a pointer to the underlying [sqlite3_vfs] object for the file. +** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter +** from the pager. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [file control opcodes] +*/ +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */ +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */ +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */ +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */ +#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */ +#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19 +#define SQLITE_TESTCTRL_NEVER_CORRUPT 20 +#define SQLITE_TESTCTRL_VDBE_COVERAGE 21 +#define SQLITE_TESTCTRL_BYTEORDER 22 +#define SQLITE_TESTCTRL_ISINIT 23 +#define SQLITE_TESTCTRL_SORTER_MMAP 24 +#define SQLITE_TESTCTRL_IMPOSTER 25 +#define SQLITE_TESTCTRL_PARSER_COVERAGE 26 +#define SQLITE_TESTCTRL_RESULT_INTREAL 27 +#define SQLITE_TESTCTRL_PRNG_SEED 28 +#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29 +#define SQLITE_TESTCTRL_SEEK_COUNT 30 +#define SQLITE_TESTCTRL_TRACEFLAGS 31 +#define SQLITE_TESTCTRL_LAST 31 /* Largest TESTCTRL */ + +/* +** CAPI3REF: SQL Keyword Checking +** +** These routines provide access to the set of SQL language keywords +** recognized by SQLite. Applications can uses these routines to determine +** whether or not a specific identifier needs to be escaped (for example, +** by enclosing in double-quotes) so as not to confuse the parser. +** +** The sqlite3_keyword_count() interface returns the number of distinct +** keywords understood by SQLite. +** +** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and +** makes *Z point to that keyword expressed as UTF8 and writes the number +** of bytes in the keyword into *L. The string that *Z points to is not +** zero-terminated. The sqlite3_keyword_name(N,Z,L) routine returns +** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z +** or L are NULL or invalid pointers then calls to +** sqlite3_keyword_name(N,Z,L) result in undefined behavior. +** +** The sqlite3_keyword_check(Z,L) interface checks to see whether or not +** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero +** if it is and zero if not. +** +** The parser used by SQLite is forgiving. It is often possible to use +** a keyword as an identifier as long as such use does not result in a +** parsing ambiguity. For example, the statement +** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and +** creates a new table named "BEGIN" with three columns named +** "REPLACE", "PRAGMA", and "END". Nevertheless, best practice is to avoid +** using keywords as identifiers. Common techniques used to avoid keyword +** name collisions include: +**
    +**
  • Put all identifier names inside double-quotes. This is the official +** SQL way to escape identifier names. +**
  • Put identifier names inside [...]. This is not standard SQL, +** but it is what SQL Server does and so lots of programmers use this +** technique. +**
  • Begin every identifier with the letter "Z" as no SQL keywords start +** with "Z". +**
  • Include a digit somewhere in every identifier name. +**
+** +** Note that the number of keywords understood by SQLite can depend on +** compile-time options. For example, "VACUUM" is not a keyword if +** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option. Also, +** new keywords may be added to future releases of SQLite. +*/ +SQLITE_API int sqlite3_keyword_count(void); +SQLITE_API int sqlite3_keyword_name(int,const char**,int*); +SQLITE_API int sqlite3_keyword_check(const char*,int); + +/* +** CAPI3REF: Dynamic String Object +** KEYWORDS: {dynamic string} +** +** An instance of the sqlite3_str object contains a dynamically-sized +** string under construction. +** +** The lifecycle of an sqlite3_str object is as follows: +**
    +**
  1. ^The sqlite3_str object is created using [sqlite3_str_new()]. +**
  2. ^Text is appended to the sqlite3_str object using various +** methods, such as [sqlite3_str_appendf()]. +**
  3. ^The sqlite3_str object is destroyed and the string it created +** is returned using the [sqlite3_str_finish()] interface. +**
+*/ +typedef struct sqlite3_str sqlite3_str; + +/* +** CAPI3REF: Create A New Dynamic String Object +** CONSTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_new(D)] interface allocates and initializes +** a new [sqlite3_str] object. To avoid memory leaks, the object returned by +** [sqlite3_str_new()] must be freed by a subsequent call to +** [sqlite3_str_finish(X)]. +** +** ^The [sqlite3_str_new(D)] interface always returns a pointer to a +** valid [sqlite3_str] object, though in the event of an out-of-memory +** error the returned object might be a special singleton that will +** silently reject new text, always return SQLITE_NOMEM from +** [sqlite3_str_errcode()], always return 0 for +** [sqlite3_str_length()], and always return NULL from +** [sqlite3_str_finish(X)]. It is always safe to use the value +** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter +** to any of the other [sqlite3_str] methods. +** +** The D parameter to [sqlite3_str_new(D)] may be NULL. If the +** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum +** length of the string contained in the [sqlite3_str] object will be +** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead +** of [SQLITE_MAX_LENGTH]. +*/ +SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*); + +/* +** CAPI3REF: Finalize A Dynamic String +** DESTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X +** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] +** that contains the constructed string. The calling application should +** pass the returned value to [sqlite3_free()] to avoid a memory leak. +** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any +** errors were encountered during construction of the string. ^The +** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the +** string in [sqlite3_str] object X is zero bytes long. +*/ +SQLITE_API char *sqlite3_str_finish(sqlite3_str*); + +/* +** CAPI3REF: Add Content To A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces add content to an sqlite3_str object previously obtained +** from [sqlite3_str_new()]. +** +** ^The [sqlite3_str_appendf(X,F,...)] and +** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf] +** functionality of SQLite to append formatted text onto the end of +** [sqlite3_str] object X. +** +** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S +** onto the end of the [sqlite3_str] object X. N must be non-negative. +** S must contain at least N non-zero bytes of content. To append a +** zero-terminated string in its entirety, use the [sqlite3_str_appendall()] +** method instead. +** +** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of +** zero-terminated string S onto the end of [sqlite3_str] object X. +** +** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the +** single-byte character C onto the end of [sqlite3_str] object X. +** ^This method can be used, for example, to add whitespace indentation. +** +** ^The [sqlite3_str_reset(X)] method resets the string under construction +** inside [sqlite3_str] object X back to zero bytes in length. +** +** These methods do not return a result code. ^If an error occurs, that fact +** is recorded in the [sqlite3_str] object and can be recovered by a +** subsequent call to [sqlite3_str_errcode(X)]. +*/ +SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...); +SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list); +SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N); +SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn); +SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C); +SQLITE_API void sqlite3_str_reset(sqlite3_str*); + +/* +** CAPI3REF: Status Of A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces return the current status of an [sqlite3_str] object. +** +** ^If any prior errors have occurred while constructing the dynamic string +** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return +** an appropriate error code. ^The [sqlite3_str_errcode(X)] method returns +** [SQLITE_NOMEM] following any out-of-memory error, or +** [SQLITE_TOOBIG] if the size of the dynamic string exceeds +** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors. +** +** ^The [sqlite3_str_length(X)] method returns the current length, in bytes, +** of the dynamic string under construction in [sqlite3_str] object X. +** ^The length returned by [sqlite3_str_length(X)] does not include the +** zero-termination byte. +** +** ^The [sqlite3_str_value(X)] method returns a pointer to the current +** content of the dynamic string under construction in X. The value +** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X +** and might be freed or altered by any subsequent method on the same +** [sqlite3_str] object. Applications must not used the pointer returned +** [sqlite3_str_value(X)] after any subsequent method call on the same +** object. ^Applications may change the content of the string returned +** by [sqlite3_str_value(X)] as long as they do not write into any bytes +** outside the range of 0 to [sqlite3_str_length(X)] and do not read or +** write any byte after any subsequent sqlite3_str method call. +*/ +SQLITE_API int sqlite3_str_errcode(sqlite3_str*); +SQLITE_API int sqlite3_str_length(sqlite3_str*); +SQLITE_API char *sqlite3_str_value(sqlite3_str*); + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^These interfaces are used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() and sqlite3_status64() routines return +** SQLITE_OK on success and a non-zero [error code] on failure. +** +** If either the current value or the highwater mark is too large to +** be represented by a 32-bit integer, then the values returned by +** sqlite3_status() are undefined. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); +SQLITE_API int sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
+** [[SQLITE_STATUS_MEMORY_USED]] ^(
SQLITE_STATUS_MEMORY_USED
+**
This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
SQLITE_STATUS_MALLOC_SIZE
+**
This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
SQLITE_STATUS_MALLOC_COUNT
+**
This parameter records the number of separate memory allocations +** currently checked out.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
SQLITE_STATUS_PAGECACHE_USED
+**
This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
+**
This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
SQLITE_STATUS_PAGECACHE_SIZE
+**
This parameter records the largest memory allocation request +** handed to the [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_SCRATCH_USED]]
SQLITE_STATUS_SCRATCH_USED
+**
No longer used.
+** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
+**
No longer used.
+** +** [[SQLITE_STATUS_SCRATCH_SIZE]]
SQLITE_STATUS_SCRATCH_SIZE
+**
No longer used.
+** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
SQLITE_STATUS_PARSER_STACK
+**
The *pHighwater parameter records the deepest parser stack. +** The *pCurrent value is undefined. The *pHighwater value is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ +**
+** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */ +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** METHOD: sqlite3 +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
+** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
+**
This parameter returns the number of lookaside memory slots currently +** checked out.
)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
SQLITE_DBSTATUS_LOOKASIDE_HIT
+**
This parameter returns the number of malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
SQLITE_DBSTATUS_CACHE_USED
+**
This parameter returns the approximate number of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]] +** ^(
SQLITE_DBSTATUS_CACHE_USED_SHARED
+**
This parameter is similar to DBSTATUS_CACHE_USED, except that if a +** pager cache is shared between two or more connections the bytes of heap +** memory used by that pager cache is divided evenly between the attached +** connections.)^ In other words, if none of the pager caches associated +** with the database connection are shared, this request returns the same +** value as DBSTATUS_CACHE_USED. Or, if one or more or the pager caches are +** shared, the value returned by this call will be smaller than that returned +** by DBSTATUS_CACHE_USED. ^The highwater mark associated with +** SQLITE_DBSTATUS_CACHE_USED_SHARED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
SQLITE_DBSTATUS_SCHEMA_USED
+**
This parameter returns the approximate number of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
SQLITE_DBSTATUS_STMT_USED
+**
This parameter returns the approximate number of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
SQLITE_DBSTATUS_CACHE_HIT
+**
This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
SQLITE_DBSTATUS_CACHE_MISS
+**
This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
SQLITE_DBSTATUS_CACHE_WRITE
+**
This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(
SQLITE_DBSTATUS_CACHE_SPILL
+**
This parameter returns the number of dirty cache entries that have +** been written to disk in the middle of a transaction due to the page +** cache overflowing. Transactions are more efficient if they are written +** to disk all at once. When pages spill mid-transaction, that introduces +** additional overhead. This parameter can be used help identify +** inefficiencies that can be resolved by increasing the cache size. +**
+** +** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(
SQLITE_DBSTATUS_DEFERRED_FKS
+**
This parameter returns zero for the current value if and only if +** all foreign key constraints (deferred or immediate) have been +** resolved.)^ ^The highwater mark is always 0. +**
+**
+*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_DEFERRED_FKS 10 +#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11 +#define SQLITE_DBSTATUS_CACHE_SPILL 12 +#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** METHOD: sqlite3_stmt +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
+** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
SQLITE_STMTSTATUS_FULLSCAN_STEP
+**
^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
+** +** [[SQLITE_STMTSTATUS_SORT]]
SQLITE_STMTSTATUS_SORT
+**
^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
+** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
SQLITE_STMTSTATUS_AUTOINDEX
+**
^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
+** +** [[SQLITE_STMTSTATUS_VM_STEP]]
SQLITE_STMTSTATUS_VM_STEP
+**
^This is the number of virtual machine operations executed +** by the prepared statement if that number is less than or equal +** to 2147483647. The number of virtual machine operations can be +** used as a proxy for the total work done by the prepared statement. +** If the number of virtual machine operations exceeds 2147483647 +** then the value returned by this statement status code is undefined. +** +** [[SQLITE_STMTSTATUS_REPREPARE]]
SQLITE_STMTSTATUS_REPREPARE
+**
^This is the number of times that the prepare statement has been +** automatically regenerated due to schema changes or changes to +** [bound parameters] that might affect the query plan. +** +** [[SQLITE_STMTSTATUS_RUN]]
SQLITE_STMTSTATUS_RUN
+**
^This is the number of times that the prepared statement has +** been run. A single "run" for the purposes of this counter is one +** or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()]. +** The counter is incremented on the first [sqlite3_step()] call of each +** cycle. +** +** [[SQLITE_STMTSTATUS_MEMUSED]]
SQLITE_STMTSTATUS_MEMUSED
+**
^This is the approximate number of bytes of heap memory +** used to store the prepared statement. ^This value is not actually +** a counter, and so the resetFlg parameter to sqlite3_stmt_status() +** is ignored when the opcode is SQLITE_STMTSTATUS_MEMUSED. +**
+**
+*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 +#define SQLITE_STMTSTATUS_VM_STEP 4 +#define SQLITE_STMTSTATUS_REPREPARE 5 +#define SQLITE_STMTSTATUS_RUN 6 +#define SQLITE_STMTSTATUS_MEMUSED 99 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
createFlag Behavior when page is not already in cache +**
0 Do not allocate a new page. Return NULL. +**
1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
+** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
    +**
  1. sqlite3_backup_init() is called once to initialize the +** backup, +**
  2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
  3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
)^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^A call to sqlite3_backup_init() will fail, returning NULL, if +** there is already a read or read-write transaction open on the +** destination database. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
    +**
  1. the destination database was opened read-only, or +**
  2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
  3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
)^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^The sqlite3_backup_remaining() routine returns the number of pages still +** to be backed up at the conclusion of the most recent sqlite3_backup_step(). +** ^The sqlite3_backup_pagecount() routine returns the total number of pages +** in the source database at the conclusion of the most recent +** sqlite3_backup_step(). +** ^(The values returned by these functions are only updated by +** sqlite3_backup_step(). If the source database is modified in a way that +** changes the size of the source database or the number of pages remaining, +** those changes are not reflected in the output of sqlite3_backup_pagecount() +** and sqlite3_backup_remaining() until after the next +** sqlite3_backup_step().)^ +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** METHOD: sqlite3 +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connection's transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connection's transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *, const char *); +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: String Globbing +* +** ^The [sqlite3_strglob(P,X)] interface returns zero if and only if +** string X matches the [GLOB] pattern P. +** ^The definition of [GLOB] pattern matching used in +** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the +** SQL dialect understood by SQLite. ^The [sqlite3_strglob(P,X)] function +** is case sensitive. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strlike()]. +*/ +SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr); + +/* +** CAPI3REF: String LIKE Matching +* +** ^The [sqlite3_strlike(P,X,E)] interface returns zero if and only if +** string X matches the [LIKE] pattern P with escape character E. +** ^The definition of [LIKE] pattern matching used in +** [sqlite3_strlike(P,X,E)] is the same as for the "X LIKE P ESCAPE E" +** operator in the SQL dialect understood by SQLite. ^For "X LIKE P" without +** the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0. +** ^As with the LIKE operator, the [sqlite3_strlike(P,X,E)] function is case +** insensitive - equivalent upper and lower case ASCII characters match +** one another. +** +** ^The [sqlite3_strlike(P,X,E)] function matches Unicode characters, though +** only ASCII characters are case folded. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strglob()]. +*/ +SQLITE_API int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the [error log] +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** is invoked each time data is committed to a database in wal mode. +** +** ^(The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released)^, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^Note that the +** [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Checkpoints initiated by this mechanism are +** [sqlite3_wal_checkpoint_v2|PASSIVE]. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint(D,X) is equivalent to +** [sqlite3_wal_checkpoint_v2](D,X,[SQLITE_CHECKPOINT_PASSIVE],0,0).)^ +** +** In brief, sqlite3_wal_checkpoint(D,X) causes the content in the +** [write-ahead log] for database X on [database connection] D to be +** transferred into the database file and for the write-ahead log to +** be reset. See the [checkpointing] documentation for addition +** information. +** +** This interface used to be the only way to cause a checkpoint to +** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()] +** interface was added. This interface is retained for backwards +** compatibility and as a convenience for applications that need to manually +** start a callback but which do not need the full power (and corresponding +** complication) of [sqlite3_wal_checkpoint_v2()]. +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint_v2(D,X,M,L,C) interface runs a checkpoint +** operation on database X of [database connection] D in mode M. Status +** information is written back into integers pointed to by L and C.)^ +** ^(The M parameter must be a valid [checkpoint mode]:)^ +** +**
+**
SQLITE_CHECKPOINT_PASSIVE
+** ^Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish, then sync the database file if all frames +** in the log were checkpointed. ^The [busy-handler callback] +** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode. +** ^On the other hand, passive mode might leave the checkpoint unfinished +** if there are concurrent readers or writers. +** +**
SQLITE_CHECKPOINT_FULL
+** ^This mode blocks (it invokes the +** [sqlite3_busy_handler|busy-handler callback]) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. ^It then checkpoints all frames in the log file and syncs the +** database file. ^This mode blocks new database writers while it is pending, +** but new database readers are allowed to continue unimpeded. +** +**
SQLITE_CHECKPOINT_RESTART
+** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition +** that after checkpointing the log file it blocks (calls the +** [busy-handler callback]) +** until all readers are reading from the database file only. ^This ensures +** that the next writer will restart the log file from the beginning. +** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new +** database writer attempts while it is pending, but does not impede readers. +** +**
SQLITE_CHECKPOINT_TRUNCATE
+** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the +** addition that it also truncates the log file to zero bytes just prior +** to a successful return. +**
+** +** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file or to -1 if the checkpoint could not run because +** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not +** NULL,then *pnCkpt is set to the total number of checkpointed frames in the +** log file (including any that were already checkpointed before the function +** was called) or to -1 if the checkpoint could not run due to an error or +** because the database is not in WAL mode. ^Note that upon successful +** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been +** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero. +** +** ^All calls obtain an exclusive "checkpoint" lock on the database file. ^If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. ^Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** ^The SQLITE_CHECKPOINT_FULL, RESTART and TRUNCATE modes also obtain the +** exclusive "writer" lock on the database file. ^If the writer lock cannot be +** obtained immediately, and a busy-handler is configured, it is invoked and +** the writer lock retried until either the busy-handler returns 0 or the lock +** is successfully obtained. ^The busy-handler is also invoked while waiting for +** database readers as described above. ^If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. ^SQLITE_BUSY is returned in this case. +** +** ^If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases [attached] to +** [database connection] db. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. ^If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned at the end. ^If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code is returned to the caller immediately. ^If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** ^If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +** +** ^Unless it returns SQLITE_MISUSE, +** the sqlite3_wal_checkpoint_v2() interface +** sets the error information that is queried by +** [sqlite3_errcode()] and [sqlite3_errmsg()]. +** +** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface +** from SQL. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint Mode Values +** KEYWORDS: {checkpoint mode} +** +** These constants define all valid values for the "checkpoint mode" passed +** as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface. +** See the [sqlite3_wal_checkpoint_v2()] documentation for details on the +** meaning of each of these checkpoint modes. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */ +#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */ +#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */ +#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */ + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** In the call sqlite3_vtab_config(D,C,...) the D parameter is the +** [database connection] in which the virtual table is being created and +** which is passed in as the first argument to the [xConnect] or [xCreate] +** method that is invoking sqlite3_vtab_config(). The C parameter is one +** of the [virtual table configuration options]. The presence and meaning +** of parameters after C depend on which [virtual table configuration option] +** is used. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** KEYWORDS: {virtual table configuration options} +** KEYWORDS: {virtual table configuration option} +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
+** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] +**
SQLITE_VTAB_CONSTRAINT_SUPPORT
+**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
+** +** [[SQLITE_VTAB_DIRECTONLY]]
SQLITE_VTAB_DIRECTONLY
+**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_DIRECTONLY) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implmentation +** prohibits that virtual table from being used from within triggers and +** views. +**
+** +** [[SQLITE_VTAB_INNOCUOUS]]
SQLITE_VTAB_INNOCUOUS
+**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implmentation +** identify that virtual table as being safe to use from within triggers +** and views. Conceptually, the SQLITE_VTAB_INNOCUOUS tag means that the +** virtual table can do no serious harm even if it is controlled by a +** malicious hacker. Developers should avoid setting the SQLITE_VTAB_INNOCUOUS +** flag unless absolutely necessary. +**
+**
+*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 +#define SQLITE_VTAB_INNOCUOUS 2 +#define SQLITE_VTAB_DIRECTONLY 3 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Determine If Virtual Table Column Access Is For UPDATE +** +** If the sqlite3_vtab_nochange(X) routine is called within the [xColumn] +** method of a [virtual table], then it might return true if the +** column is being fetched as part of an UPDATE operation during which the +** column value will not change. The virtual table implementation can use +** this hint as permission to substitute a return value that is less +** expensive to compute and that the corresponding +** [xUpdate] method understands as a "no-change" value. +** +** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that +** the column is not changed by the UPDATE statement, then the xColumn +** method can optionally return without setting a result, without calling +** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces]. +** In that case, [sqlite3_value_nochange(X)] will return true for the +** same column in the [xUpdate] method. +** +** The sqlite3_vtab_nochange() routine is an optimization. Virtual table +** implementations should continue to give a correct answer even if the +** sqlite3_vtab_nochange() interface were to always return false. In the +** current implementation, the sqlite3_vtab_nochange() interface does always +** returns false for the enhanced [UPDATE FROM] statement. +*/ +SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*); + +/* +** CAPI3REF: Determine The Collation For a Virtual Table Constraint +** +** This function may only be called from within a call to the [xBestIndex] +** method of a [virtual table]. +** +** The first argument must be the sqlite3_index_info object that is the +** first parameter to the xBestIndex() method. The second argument must be +** an index into the aConstraint[] array belonging to the sqlite3_index_info +** structure passed to xBestIndex. This function returns a pointer to a buffer +** containing the name of the collation sequence for the corresponding +** constraint. +*/ +SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int); + +/* +** CAPI3REF: Conflict resolution modes +** KEYWORDS: {conflict resolution mode} +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + +/* +** CAPI3REF: Prepared Statement Scan Status Opcodes +** KEYWORDS: {scanstatus options} +** +** The following constants can be used for the T parameter to the +** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a +** different metric for sqlite3_stmt_scanstatus() to return. +** +** When the value returned to V is a string, space to hold that string is +** managed by the prepared statement S and will be automatically freed when +** S is finalized. +** +**
+** [[SQLITE_SCANSTAT_NLOOP]]
SQLITE_SCANSTAT_NLOOP
+**
^The [sqlite3_int64] variable pointed to by the V parameter will be +** set to the total number of times that the X-th loop has run.
+** +** [[SQLITE_SCANSTAT_NVISIT]]
SQLITE_SCANSTAT_NVISIT
+**
^The [sqlite3_int64] variable pointed to by the V parameter will be set +** to the total number of rows examined by all iterations of the X-th loop.
+** +** [[SQLITE_SCANSTAT_EST]]
SQLITE_SCANSTAT_EST
+**
^The "double" variable pointed to by the V parameter will be set to the +** query planner's estimate for the average number of rows output from each +** iteration of the X-th loop. If the query planner's estimates was accurate, +** then this value will approximate the quotient NVISIT/NLOOP and the +** product of this value for all prior loops with the same SELECTID will +** be the NLOOP value for the current loop. +** +** [[SQLITE_SCANSTAT_NAME]]
SQLITE_SCANSTAT_NAME
+**
^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the name of the index or table +** used for the X-th loop. +** +** [[SQLITE_SCANSTAT_EXPLAIN]]
SQLITE_SCANSTAT_EXPLAIN
+**
^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN] +** description for the X-th loop. +** +** [[SQLITE_SCANSTAT_SELECTID]]
SQLITE_SCANSTAT_SELECT
+**
^The "int" variable pointed to by the V parameter will be set to the +** "select-id" for the X-th loop. The select-id identifies which query or +** subquery the loop is part of. The main query has a select-id of zero. +** The select-id is the same value as is output in the first column +** of an [EXPLAIN QUERY PLAN] query. +**
+*/ +#define SQLITE_SCANSTAT_NLOOP 0 +#define SQLITE_SCANSTAT_NVISIT 1 +#define SQLITE_SCANSTAT_EST 2 +#define SQLITE_SCANSTAT_NAME 3 +#define SQLITE_SCANSTAT_EXPLAIN 4 +#define SQLITE_SCANSTAT_SELECTID 5 + +/* +** CAPI3REF: Prepared Statement Scan Status +** METHOD: sqlite3_stmt +** +** This interface returns information about the predicted and measured +** performance for pStmt. Advanced applications can use this +** interface to compare the predicted and the measured performance and +** issue warnings and/or rerun [ANALYZE] if discrepancies are found. +** +** Since this interface is expected to be rarely used, it is only +** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS] +** compile-time option. +** +** The "iScanStatusOp" parameter determines which status information to return. +** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior +** of this interface is undefined. +** ^The requested measurement is written into a variable pointed to by +** the "pOut" parameter. +** Parameter "idx" identifies the specific loop to retrieve statistics for. +** Loops are numbered starting from zero. ^If idx is out of range - less than +** zero or greater than or equal to the total number of loops used to implement +** the statement - a non-zero value is returned and the variable that pOut +** points to is unchanged. +** +** ^Statistics might not be available for all loops in all statements. ^In cases +** where there exist loops with no available statistics, this function behaves +** as if the loop did not exist - it returns non-zero and leave the variable +** that pOut points to unchanged. +** +** See also: [sqlite3_stmt_scanstatus_reset()] +*/ +SQLITE_API int sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement for which info desired */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */ + void *pOut /* Result written here */ +); + +/* +** CAPI3REF: Zero Scan-Status Counters +** METHOD: sqlite3_stmt +** +** ^Zero all [sqlite3_stmt_scanstatus()] related event counters. +** +** This API is only available if the library is built with pre-processor +** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined. +*/ +SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*); + +/* +** CAPI3REF: Flush caches to disk mid-transaction +** METHOD: sqlite3 +** +** ^If a write-transaction is open on [database connection] D when the +** [sqlite3_db_cacheflush(D)] interface invoked, any dirty +** pages in the pager-cache that are not currently in use are written out +** to disk. A dirty page may be in use if a database cursor created by an +** active SQL statement is reading from it, or if it is page 1 of a database +** file (page 1 is always "in use"). ^The [sqlite3_db_cacheflush(D)] +** interface flushes caches for all schemas - "main", "temp", and +** any [attached] databases. +** +** ^If this function needs to obtain extra database locks before dirty pages +** can be flushed to disk, it does so. ^If those locks cannot be obtained +** immediately and there is a busy-handler callback configured, it is invoked +** in the usual manner. ^If the required lock still cannot be obtained, then +** the database is skipped and an attempt made to flush any dirty pages +** belonging to the next (if any) database. ^If any databases are skipped +** because locks cannot be obtained, but no other error occurs, this +** function returns SQLITE_BUSY. +** +** ^If any other error occurs while flushing dirty pages to disk (for +** example an IO error or out-of-memory condition), then processing is +** abandoned and an SQLite [error code] is returned to the caller immediately. +** +** ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK. +** +** ^This function does not set the database handle error code or message +** returned by the [sqlite3_errcode()] and [sqlite3_errmsg()] functions. +*/ +SQLITE_API int sqlite3_db_cacheflush(sqlite3*); + +/* +** CAPI3REF: The pre-update hook. +** METHOD: sqlite3 +** +** ^These interfaces are only available if SQLite is compiled using the +** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option. +** +** ^The [sqlite3_preupdate_hook()] interface registers a callback function +** that is invoked prior to each [INSERT], [UPDATE], and [DELETE] operation +** on a database table. +** ^At most one preupdate hook may be registered at a time on a single +** [database connection]; each call to [sqlite3_preupdate_hook()] overrides +** the previous setting. +** ^The preupdate hook is disabled by invoking [sqlite3_preupdate_hook()] +** with a NULL pointer as the second parameter. +** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as +** the first parameter to callbacks. +** +** ^The preupdate hook only fires for changes to real database tables; the +** preupdate hook is not invoked for changes to [virtual tables] or to +** system tables like sqlite_sequence or sqlite_stat1. +** +** ^The second parameter to the preupdate callback is a pointer to +** the [database connection] that registered the preupdate hook. +** ^The third parameter to the preupdate callback is one of the constants +** [SQLITE_INSERT], [SQLITE_DELETE], or [SQLITE_UPDATE] to identify the +** kind of update operation that is about to occur. +** ^(The fourth parameter to the preupdate callback is the name of the +** database within the database connection that is being modified. This +** will be "main" for the main database or "temp" for TEMP tables or +** the name given after the AS keyword in the [ATTACH] statement for attached +** databases.)^ +** ^The fifth parameter to the preupdate callback is the name of the +** table that is being modified. +** +** For an UPDATE or DELETE operation on a [rowid table], the sixth +** parameter passed to the preupdate callback is the initial [rowid] of the +** row being modified or deleted. For an INSERT operation on a rowid table, +** or any operation on a WITHOUT ROWID table, the value of the sixth +** parameter is undefined. For an INSERT or UPDATE on a rowid table the +** seventh parameter is the final rowid value of the row being inserted +** or updated. The value of the seventh parameter passed to the callback +** function is not defined for operations on WITHOUT ROWID tables, or for +** DELETE operations on rowid tables. +** +** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()], +** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces +** provide additional information about a preupdate event. These routines +** may only be called from within a preupdate callback. Invoking any of +** these routines from outside of a preupdate callback or with a +** [database connection] pointer that is different from the one supplied +** to the preupdate callback results in undefined and probably undesirable +** behavior. +** +** ^The [sqlite3_preupdate_count(D)] interface returns the number of columns +** in the row that is being inserted, updated, or deleted. +** +** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row before it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE +** preupdate callbacks; if it is used by an SQLITE_INSERT callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row after it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE +** preupdate callbacks; if it is used by an SQLITE_DELETE callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_depth(D)] interface returns 0 if the preupdate +** callback was invoked as a result of a direct insert, update, or delete +** operation; or 1 for inserts, updates, or deletes invoked by top-level +** triggers; or 2 for changes resulting from triggers called by top-level +** triggers; and so forth. +** +** See also: [sqlite3_update_hook()] +*/ +#if defined(SQLITE_ENABLE_PREUPDATE_HOOK) +SQLITE_API void *sqlite3_preupdate_hook( + sqlite3 *db, + void(*xPreUpdate)( + void *pCtx, /* Copy of third arg to preupdate_hook() */ + sqlite3 *db, /* Database handle */ + int op, /* SQLITE_UPDATE, DELETE or INSERT */ + char const *zDb, /* Database name */ + char const *zName, /* Table name */ + sqlite3_int64 iKey1, /* Rowid of row about to be deleted/updated */ + sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */ + ), + void* +); +SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_count(sqlite3 *); +SQLITE_API int sqlite3_preupdate_depth(sqlite3 *); +SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **); +#endif + +/* +** CAPI3REF: Low-level system error code +** METHOD: sqlite3 +** +** ^Attempt to return the underlying operating system error code or error +** number that caused the most recent I/O error or failure to open a file. +** The return value is OS-dependent. For example, on unix systems, after +** [sqlite3_open_v2()] returns [SQLITE_CANTOPEN], this interface could be +** called to get back the underlying "errno" that caused the problem, such +** as ENOSPC, EAUTH, EISDIR, and so forth. +*/ +SQLITE_API int sqlite3_system_errno(sqlite3*); + +/* +** CAPI3REF: Database Snapshot +** KEYWORDS: {snapshot} {sqlite3_snapshot} +** +** An instance of the snapshot object records the state of a [WAL mode] +** database for some specific point in history. +** +** In [WAL mode], multiple [database connections] that are open on the +** same database file can each be reading a different historical version +** of the database file. When a [database connection] begins a read +** transaction, that connection sees an unchanging copy of the database +** as it existed for the point in time when the transaction first started. +** Subsequent changes to the database from other connections are not seen +** by the reader until a new read transaction is started. +** +** The sqlite3_snapshot object records state information about an historical +** version of the database file so that it is possible to later open a new read +** transaction that sees that historical version of the database rather than +** the most recent version. +*/ +typedef struct sqlite3_snapshot { + unsigned char hidden[48]; +} sqlite3_snapshot; + +/* +** CAPI3REF: Record A Database Snapshot +** CONSTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a +** new [sqlite3_snapshot] object that records the current state of +** schema S in database connection D. ^On success, the +** [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly +** created [sqlite3_snapshot] object into *P and returns SQLITE_OK. +** If there is not already a read-transaction open on schema S when +** this function is called, one is opened automatically. +** +** The following must be true for this function to succeed. If any of +** the following statements are false when sqlite3_snapshot_get() is +** called, SQLITE_ERROR is returned. The final value of *P is undefined +** in this case. +** +**
    +**
  • The database handle must not be in [autocommit mode]. +** +**
  • Schema S of [database connection] D must be a [WAL mode] database. +** +**
  • There must not be a write transaction open on schema S of database +** connection D. +** +**
  • One or more transactions must have been written to the current wal +** file since it was created on disk (by any connection). This means +** that a snapshot cannot be taken on a wal mode database with no wal +** file immediately after it is first opened. At least one transaction +** must be written to it first. +**
+** +** This function may also return SQLITE_NOMEM. If it is called with the +** database handle in autocommit mode but fails for some other reason, +** whether or not a read transaction is opened on schema S is undefined. +** +** The [sqlite3_snapshot] object returned from a successful call to +** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()] +** to avoid a memory leak. +** +** The [sqlite3_snapshot_get()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot **ppSnapshot +); + +/* +** CAPI3REF: Start a read transaction on an historical snapshot +** METHOD: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read +** transaction or upgrades an existing one for schema S of +** [database connection] D such that the read transaction refers to +** historical [snapshot] P, rather than the most recent change to the +** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK +** on success or an appropriate [error code] if it fails. +** +** ^In order to succeed, the database connection must not be in +** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there +** is already a read transaction open on schema S, then the database handle +** must have no active statements (SELECT statements that have been passed +** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()). +** SQLITE_ERROR is returned if either of these conditions is violated, or +** if schema S does not exist, or if the snapshot object is invalid. +** +** ^A call to sqlite3_snapshot_open() will fail to open if the specified +** snapshot has been overwritten by a [checkpoint]. In this case +** SQLITE_ERROR_SNAPSHOT is returned. +** +** If there is already a read transaction open when this function is +** invoked, then the same read transaction remains open (on the same +** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT +** is returned. If another error code - for example SQLITE_PROTOCOL or an +** SQLITE_IOERR error code - is returned, then the final state of the +** read transaction is undefined. If SQLITE_OK is returned, then the +** read transaction is now open on database snapshot P. +** +** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the +** database connection D does not know that the database file for +** schema S is in [WAL mode]. A database connection might not know +** that the database file is in [WAL mode] if there has been no prior +** I/O on that database connection, or if the database entered [WAL mode] +** after the most recent I/O on the database connection.)^ +** (Hint: Run "[PRAGMA application_id]" against a newly opened +** database connection in order to make it ready to use snapshots.) +** +** The [sqlite3_snapshot_open()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot *pSnapshot +); + +/* +** CAPI3REF: Destroy a snapshot +** DESTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P. +** The application must eventually free every [sqlite3_snapshot] object +** using this routine to avoid a memory leak. +** +** The [sqlite3_snapshot_free()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*); + +/* +** CAPI3REF: Compare the ages of two snapshot handles. +** METHOD: sqlite3_snapshot +** +** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages +** of two valid snapshot handles. +** +** If the two snapshot handles are not associated with the same database +** file, the result of the comparison is undefined. +** +** Additionally, the result of the comparison is only valid if both of the +** snapshot handles were obtained by calling sqlite3_snapshot_get() since the +** last time the wal file was deleted. The wal file is deleted when the +** database is changed back to rollback mode or when the number of database +** clients drops to zero. If either snapshot handle was obtained before the +** wal file was last deleted, the value returned by this function +** is undefined. +** +** Otherwise, this API returns a negative value if P1 refers to an older +** snapshot than P2, zero if the two handles refer to the same database +** snapshot, and a positive value if P1 is a newer snapshot than P2. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp( + sqlite3_snapshot *p1, + sqlite3_snapshot *p2 +); + +/* +** CAPI3REF: Recover snapshots from a wal file +** METHOD: sqlite3_snapshot +** +** If a [WAL file] remains on disk after all database connections close +** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control] +** or because the last process to have the database opened exited without +** calling [sqlite3_close()]) and a new connection is subsequently opened +** on that database and [WAL file], the [sqlite3_snapshot_open()] interface +** will only be able to open the last transaction added to the WAL file +** even though the WAL file contains other valid transactions. +** +** This function attempts to scan the WAL file associated with database zDb +** of database handle db and make all valid snapshots available to +** sqlite3_snapshot_open(). It is an error if there is already a read +** transaction open on the database, or if the database is not a WAL mode +** database. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Serialize a database +** +** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory +** that is a serialization of the S database on [database connection] D. +** If P is not a NULL pointer, then the size of the database in bytes +** is written into *P. +** +** For an ordinary on-disk database file, the serialization is just a +** copy of the disk file. For an in-memory database or a "TEMP" database, +** the serialization is the same sequence of bytes which would be written +** to disk if that database where backed up to disk. +** +** The usual case is that sqlite3_serialize() copies the serialization of +** the database into memory obtained from [sqlite3_malloc64()] and returns +** a pointer to that memory. The caller is responsible for freeing the +** returned value to avoid a memory leak. However, if the F argument +** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations +** are made, and the sqlite3_serialize() function will return a pointer +** to the contiguous memory representation of the database that SQLite +** is currently using for that database, or NULL if the no such contiguous +** memory representation of the database exists. A contiguous memory +** representation of the database will usually only exist if there has +** been a prior call to [sqlite3_deserialize(D,S,...)] with the same +** values of D and S. +** The size of the database is written into *P even if the +** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy +** of the database exists. +** +** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the +** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory +** allocation error occurs. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_DESERIALIZE] option. +*/ +SQLITE_API unsigned char *sqlite3_serialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to serialize. ex: "main", "temp", ... */ + sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */ + unsigned int mFlags /* Zero or more SQLITE_SERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_serialize +** +** Zero or more of the following constants can be OR-ed together for +** the F argument to [sqlite3_serialize(D,S,P,F)]. +** +** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return +** a pointer to contiguous in-memory database that it is currently using, +** without making a copy of the database. If SQLite is not currently using +** a contiguous in-memory database, then this option causes +** [sqlite3_serialize()] to return a NULL pointer. SQLite will only be +** using a contiguous in-memory database if it has been initialized by a +** prior call to [sqlite3_deserialize()]. +*/ +#define SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */ + +/* +** CAPI3REF: Deserialize a database +** +** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the +** [database connection] D to disconnect from database S and then +** reopen S as an in-memory database based on the serialization contained +** in P. The serialized database P is N bytes in size. M is the size of +** the buffer P, which might be larger than N. If M is larger than N, and +** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is +** permitted to add content to the in-memory database as long as the total +** size does not exceed M bytes. +** +** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will +** invoke sqlite3_free() on the serialization buffer when the database +** connection closes. If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then +** SQLite will try to increase the buffer size using sqlite3_realloc64() +** if writes on the database cause it to grow larger than M bytes. +** +** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the +** database is currently in a read transaction or is involved in a backup +** operation. +** +** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the +** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then +** [sqlite3_free()] is invoked on argument P prior to returning. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_DESERIALIZE] option. +*/ +SQLITE_API int sqlite3_deserialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to reopen with the deserialization */ + unsigned char *pData, /* The serialized database content */ + sqlite3_int64 szDb, /* Number bytes in the deserialization */ + sqlite3_int64 szBuf, /* Total size of buffer pData[] */ + unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_deserialize() +** +** The following are allowed values for 6th argument (the F argument) to +** the [sqlite3_deserialize(D,S,P,N,M,F)] interface. +** +** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization +** in the P argument is held in memory obtained from [sqlite3_malloc64()] +** and that SQLite should take ownership of this memory and automatically +** free it when it has finished using it. Without this flag, the caller +** is responsible for freeing any dynamically allocated memory. +** +** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to +** grow the size of the database using calls to [sqlite3_realloc64()]. This +** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. +** Without this flag, the deserialized database cannot increase in size beyond +** the number of bytes specified by the M parameter. +** +** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database +** should be treated as read-only. +*/ +#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */ +#define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */ +#define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */ + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif /* SQLITE3_H */ + +/******** Begin file sqlite3rtree.h *********/ +/* +** 2010 August 30 +** +** 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. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; +typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info; + +/* The double-precision datatype used by RTree depends on the +** SQLITE_RTREE_INT_ONLY compile-time option. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 sqlite3_rtree_dbl; +#else + typedef double sqlite3_rtree_dbl; +#endif + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, + int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*), + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + sqlite3_rtree_dbl *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + +/* +** Register a 2nd-generation geometry callback named zScore that can be +** used as part of an R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zQueryFunc(... params ...) +*/ +SQLITE_API int sqlite3_rtree_query_callback( + sqlite3 *db, + const char *zQueryFunc, + int (*xQueryFunc)(sqlite3_rtree_query_info*), + void *pContext, + void (*xDestructor)(void*) +); + + +/* +** A pointer to a structure of the following type is passed as the +** argument to scored geometry callback registered using +** sqlite3_rtree_query_callback(). +** +** Note that the first 5 fields of this structure are identical to +** sqlite3_rtree_geometry. This structure is a subclass of +** sqlite3_rtree_geometry. +*/ +struct sqlite3_rtree_query_info { + void *pContext; /* pContext from when function registered */ + int nParam; /* Number of function parameters */ + sqlite3_rtree_dbl *aParam; /* value of function parameters */ + void *pUser; /* callback can use this, if desired */ + void (*xDelUser)(void*); /* function to free pUser */ + sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */ + unsigned int *anQueue; /* Number of pending entries in the queue */ + int nCoord; /* Number of coordinates */ + int iLevel; /* Level of current node or entry */ + int mxLevel; /* The largest iLevel value in the tree */ + sqlite3_int64 iRowid; /* Rowid for current entry */ + sqlite3_rtree_dbl rParentScore; /* Score of parent node */ + int eParentWithin; /* Visibility of parent node */ + int eWithin; /* OUT: Visibility */ + sqlite3_rtree_dbl rScore; /* OUT: Write the score here */ + /* The following fields are only available in 3.8.11 and later */ + sqlite3_value **apSqlParam; /* Original SQL values of parameters */ +}; + +/* +** Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. +*/ +#define NOT_WITHIN 0 /* Object completely outside of query region */ +#define PARTLY_WITHIN 1 /* Object partially overlaps query region */ +#define FULLY_WITHIN 2 /* Object fully contained within query region */ + + +#ifdef __cplusplus +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + +/******** End of sqlite3rtree.h *********/ +/******** Begin file sqlite3session.h *********/ + +#if !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) +#define __SQLITESESSION_H_ 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +extern "C" { +#endif + + +/* +** CAPI3REF: Session Object Handle +** +** An instance of this object is a [session] that can be used to +** record changes to a database. +*/ +typedef struct sqlite3_session sqlite3_session; + +/* +** CAPI3REF: Changeset Iterator Handle +** +** An instance of this object acts as a cursor for iterating +** over the elements of a [changeset] or [patchset]. +*/ +typedef struct sqlite3_changeset_iter sqlite3_changeset_iter; + +/* +** CAPI3REF: Create A New Session Object +** CONSTRUCTOR: sqlite3_session +** +** Create a new session object attached to database handle db. If successful, +** a pointer to the new object is written to *ppSession and SQLITE_OK is +** returned. If an error occurs, *ppSession is set to NULL and an SQLite +** error code (e.g. SQLITE_NOMEM) is returned. +** +** It is possible to create multiple session objects attached to a single +** database handle. +** +** Session objects created using this function should be deleted using the +** [sqlite3session_delete()] function before the database handle that they +** are attached to is itself closed. If the database handle is closed before +** the session object is deleted, then the results of calling any session +** module function, including [sqlite3session_delete()] on the session object +** are undefined. +** +** Because the session module uses the [sqlite3_preupdate_hook()] API, it +** is not possible for an application to register a pre-update hook on a +** database handle that has one or more session objects attached. Nor is +** it possible to create a session object attached to a database handle for +** which a pre-update hook is already defined. The results of attempting +** either of these things are undefined. +** +** The session object will be used to create changesets for tables in +** database zDb, where zDb is either "main", or "temp", or the name of an +** attached database. It is not an error if database zDb is not attached +** to the database when the session object is created. +*/ +SQLITE_API int sqlite3session_create( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (e.g. "main") */ + sqlite3_session **ppSession /* OUT: New session object */ +); + +/* +** CAPI3REF: Delete A Session Object +** DESTRUCTOR: sqlite3_session +** +** Delete a session object previously allocated using +** [sqlite3session_create()]. Once a session object has been deleted, the +** results of attempting to use pSession with any other session module +** function are undefined. +** +** Session objects must be deleted before the database handle to which they +** are attached is closed. Refer to the documentation for +** [sqlite3session_create()] for details. +*/ +SQLITE_API void sqlite3session_delete(sqlite3_session *pSession); + + +/* +** CAPI3REF: Enable Or Disable A Session Object +** METHOD: sqlite3_session +** +** Enable or disable the recording of changes by a session object. When +** enabled, a session object records changes made to the database. When +** disabled - it does not. A newly created session object is enabled. +** Refer to the documentation for [sqlite3session_changeset()] for further +** details regarding how enabling and disabling a session object affects +** the eventual changesets. +** +** Passing zero to this function disables the session. Passing a value +** greater than zero enables it. Passing a value less than zero is a +** no-op, and may be used to query the current state of the session. +** +** The return value indicates the final state of the session object: 0 if +** the session is disabled, or 1 if it is enabled. +*/ +SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable); + +/* +** CAPI3REF: Set Or Clear the Indirect Change Flag +** METHOD: sqlite3_session +** +** Each change recorded by a session object is marked as either direct or +** indirect. A change is marked as indirect if either: +** +**
    +**
  • The session object "indirect" flag is set when the change is +** made, or +**
  • The change is made by an SQL trigger or foreign key action +** instead of directly as a result of a users SQL statement. +**
+** +** If a single row is affected by more than one operation within a session, +** then the change is considered indirect if all operations meet the criteria +** for an indirect change above, or direct otherwise. +** +** This function is used to set, clear or query the session object indirect +** flag. If the second argument passed to this function is zero, then the +** indirect flag is cleared. If it is greater than zero, the indirect flag +** is set. Passing a value less than zero does not modify the current value +** of the indirect flag, and may be used to query the current state of the +** indirect flag for the specified session object. +** +** The return value indicates the final state of the indirect flag: 0 if +** it is clear, or 1 if it is set. +*/ +SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect); + +/* +** CAPI3REF: Attach A Table To A Session Object +** METHOD: sqlite3_session +** +** If argument zTab is not NULL, then it is the name of a table to attach +** to the session object passed as the first argument. All subsequent changes +** made to the table while the session object is enabled will be recorded. See +** documentation for [sqlite3session_changeset()] for further details. +** +** Or, if argument zTab is NULL, then changes are recorded for all tables +** in the database. If additional tables are added to the database (by +** executing "CREATE TABLE" statements) after this call is made, changes for +** the new tables are also recorded. +** +** Changes can only be recorded for tables that have a PRIMARY KEY explicitly +** defined as part of their CREATE TABLE statement. It does not matter if the +** PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias) or not. The PRIMARY +** KEY may consist of a single column, or may be a composite key. +** +** It is not an error if the named table does not exist in the database. Nor +** is it an error if the named table does not have a PRIMARY KEY. However, +** no changes will be recorded in either of these scenarios. +** +** Changes are not recorded for individual rows that have NULL values stored +** in one or more of their PRIMARY KEY columns. +** +** SQLITE_OK is returned if the call completes without error. Or, if an error +** occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned. +** +**

Special sqlite_stat1 Handling

+** +** As of SQLite version 3.22.0, the "sqlite_stat1" table is an exception to +** some of the rules above. In SQLite, the schema of sqlite_stat1 is: +** 
+**        CREATE TABLE sqlite_stat1(tbl,idx,stat)
+**
+** +** Even though sqlite_stat1 does not have a PRIMARY KEY, changes are +** recorded for it as if the PRIMARY KEY is (tbl,idx). Additionally, changes +** are recorded for rows for which (idx IS NULL) is true. However, for such +** rows a zero-length blob (SQL value X'') is stored in the changeset or +** patchset instead of a NULL value. This allows such changesets to be +** manipulated by legacy implementations of sqlite3changeset_invert(), +** concat() and similar. +** +** The sqlite3changeset_apply() function automatically converts the +** zero-length blob back to a NULL value when updating the sqlite_stat1 +** table. However, if the application calls sqlite3changeset_new(), +** sqlite3changeset_old() or sqlite3changeset_conflict on a changeset +** iterator directly (including on a changeset iterator passed to a +** conflict-handler callback) then the X'' value is returned. The application +** must translate X'' to NULL itself if required. +** +** Legacy (older than 3.22.0) versions of the sessions module cannot capture +** changes made to the sqlite_stat1 table. Legacy versions of the +** sqlite3changeset_apply() function silently ignore any modifications to the +** sqlite_stat1 table that are part of a changeset or patchset. +*/ +SQLITE_API int sqlite3session_attach( + sqlite3_session *pSession, /* Session object */ + const char *zTab /* Table name */ +); + +/* +** CAPI3REF: Set a table filter on a Session Object. +** METHOD: sqlite3_session +** +** The second argument (xFilter) is the "filter callback". For changes to rows +** in tables that are not attached to the Session object, the filter is called +** to determine whether changes to the table's rows should be tracked or not. +** If xFilter returns 0, changes are not tracked. Note that once a table is +** attached, xFilter will not be called again. +*/ +SQLITE_API void sqlite3session_table_filter( + sqlite3_session *pSession, /* Session object */ + int(*xFilter)( + void *pCtx, /* Copy of third arg to _filter_table() */ + const char *zTab /* Table name */ + ), + void *pCtx /* First argument passed to xFilter */ +); + +/* +** CAPI3REF: Generate A Changeset From A Session Object +** METHOD: sqlite3_session +** +** Obtain a changeset containing changes to the tables attached to the +** session object passed as the first argument. If successful, +** set *ppChangeset to point to a buffer containing the changeset +** and *pnChangeset to the size of the changeset in bytes before returning +** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to +** zero and return an SQLite error code. +** +** A changeset consists of zero or more INSERT, UPDATE and/or DELETE changes, +** each representing a change to a single row of an attached table. An INSERT +** change contains the values of each field of a new database row. A DELETE +** contains the original values of each field of a deleted database row. An +** UPDATE change contains the original values of each field of an updated +** database row along with the updated values for each updated non-primary-key +** column. It is not possible for an UPDATE change to represent a change that +** modifies the values of primary key columns. If such a change is made, it +** is represented in a changeset as a DELETE followed by an INSERT. +** +** Changes are not recorded for rows that have NULL values stored in one or +** more of their PRIMARY KEY columns. If such a row is inserted or deleted, +** no corresponding change is present in the changesets returned by this +** function. If an existing row with one or more NULL values stored in +** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL, +** only an INSERT is appears in the changeset. Similarly, if an existing row +** with non-NULL PRIMARY KEY values is updated so that one or more of its +** PRIMARY KEY columns are set to NULL, the resulting changeset contains a +** DELETE change only. +** +** The contents of a changeset may be traversed using an iterator created +** using the [sqlite3changeset_start()] API. A changeset may be applied to +** a database with a compatible schema using the [sqlite3changeset_apply()] +** API. +** +** Within a changeset generated by this function, all changes related to a +** single table are grouped together. In other words, when iterating through +** a changeset or when applying a changeset to a database, all changes related +** to a single table are processed before moving on to the next table. Tables +** are sorted in the same order in which they were attached (or auto-attached) +** to the sqlite3_session object. The order in which the changes related to +** a single table are stored is undefined. +** +** Following a successful call to this function, it is the responsibility of +** the caller to eventually free the buffer that *ppChangeset points to using +** [sqlite3_free()]. +** +**

Changeset Generation

+** +** Once a table has been attached to a session object, the session object +** records the primary key values of all new rows inserted into the table. +** It also records the original primary key and other column values of any +** deleted or updated rows. For each unique primary key value, data is only +** recorded once - the first time a row with said primary key is inserted, +** updated or deleted in the lifetime of the session. +** +** There is one exception to the previous paragraph: when a row is inserted, +** updated or deleted, if one or more of its primary key columns contain a +** NULL value, no record of the change is made. +** +** The session object therefore accumulates two types of records - those +** that consist of primary key values only (created when the user inserts +** a new record) and those that consist of the primary key values and the +** original values of other table columns (created when the users deletes +** or updates a record). +** +** When this function is called, the requested changeset is created using +** both the accumulated records and the current contents of the database +** file. Specifically: +** +**
    +**
  • For each record generated by an insert, the database is queried +** for a row with a matching primary key. If one is found, an INSERT +** change is added to the changeset. If no such row is found, no change +** is added to the changeset. +** +**
  • For each record generated by an update or delete, the database is +** queried for a row with a matching primary key. If such a row is +** found and one or more of the non-primary key fields have been +** modified from their original values, an UPDATE change is added to +** the changeset. Or, if no such row is found in the table, a DELETE +** change is added to the changeset. If there is a row with a matching +** primary key in the database, but all fields contain their original +** values, no change is added to the changeset. +**
+** +** This means, amongst other things, that if a row is inserted and then later +** deleted while a session object is active, neither the insert nor the delete +** will be present in the changeset. Or if a row is deleted and then later a +** row with the same primary key values inserted while a session object is +** active, the resulting changeset will contain an UPDATE change instead of +** a DELETE and an INSERT. +** +** When a session object is disabled (see the [sqlite3session_enable()] API), +** it does not accumulate records when rows are inserted, updated or deleted. +** This may appear to have some counter-intuitive effects if a single row +** is written to more than once during a session. For example, if a row +** is inserted while a session object is enabled, then later deleted while +** the same session object is disabled, no INSERT record will appear in the +** changeset, even though the delete took place while the session was disabled. +** Or, if one field of a row is updated while a session is disabled, and +** another field of the same row is updated while the session is enabled, the +** resulting changeset will contain an UPDATE change that updates both fields. +*/ +SQLITE_API int sqlite3session_changeset( + sqlite3_session *pSession, /* Session object */ + int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */ + void **ppChangeset /* OUT: Buffer containing changeset */ +); + +/* +** CAPI3REF: Load The Difference Between Tables Into A Session +** METHOD: sqlite3_session +** +** If it is not already attached to the session object passed as the first +** argument, this function attaches table zTbl in the same manner as the +** [sqlite3session_attach()] function. If zTbl does not exist, or if it +** does not have a primary key, this function is a no-op (but does not return +** an error). +** +** Argument zFromDb must be the name of a database ("main", "temp" etc.) +** attached to the same database handle as the session object that contains +** a table compatible with the table attached to the session by this function. +** A table is considered compatible if it: +** +**
    +**
  • Has the same name, +**
  • Has the same set of columns declared in the same order, and +**
  • Has the same PRIMARY KEY definition. +**
+** +** If the tables are not compatible, SQLITE_SCHEMA is returned. If the tables +** are compatible but do not have any PRIMARY KEY columns, it is not an error +** but no changes are added to the session object. As with other session +** APIs, tables without PRIMARY KEYs are simply ignored. +** +** This function adds a set of changes to the session object that could be +** used to update the table in database zFrom (call this the "from-table") +** so that its content is the same as the table attached to the session +** object (call this the "to-table"). Specifically: +** +**
    +**
  • For each row (primary key) that exists in the to-table but not in +** the from-table, an INSERT record is added to the session object. +** +**
  • For each row (primary key) that exists in the to-table but not in +** the from-table, a DELETE record is added to the session object. +** +**
  • For each row (primary key) that exists in both tables, but features +** different non-PK values in each, an UPDATE record is added to the +** session. +**
+** +** To clarify, if this function is called and then a changeset constructed +** using [sqlite3session_changeset()], then after applying that changeset to +** database zFrom the contents of the two compatible tables would be +** identical. +** +** It an error if database zFrom does not exist or does not contain the +** required compatible table. +** +** If the operation is successful, SQLITE_OK is returned. Otherwise, an SQLite +** error code. In this case, if argument pzErrMsg is not NULL, *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to free this buffer using +** sqlite3_free(). +*/ +SQLITE_API int sqlite3session_diff( + sqlite3_session *pSession, + const char *zFromDb, + const char *zTbl, + char **pzErrMsg +); + + +/* +** CAPI3REF: Generate A Patchset From A Session Object +** METHOD: sqlite3_session +** +** The differences between a patchset and a changeset are that: +** +**
    +**
  • DELETE records consist of the primary key fields only. The +** original values of other fields are omitted. +**
  • The original values of any modified fields are omitted from +** UPDATE records. +**
+** +** A patchset blob may be used with up to date versions of all +** sqlite3changeset_xxx API functions except for sqlite3changeset_invert(), +** which returns SQLITE_CORRUPT if it is passed a patchset. Similarly, +** attempting to use a patchset blob with old versions of the +** sqlite3changeset_xxx APIs also provokes an SQLITE_CORRUPT error. +** +** Because the non-primary key "old.*" fields are omitted, no +** SQLITE_CHANGESET_DATA conflicts can be detected or reported if a patchset +** is passed to the sqlite3changeset_apply() API. Other conflict types work +** in the same way as for changesets. +** +** Changes within a patchset are ordered in the same way as for changesets +** generated by the sqlite3session_changeset() function (i.e. all changes for +** a single table are grouped together, tables appear in the order in which +** they were attached to the session object). +*/ +SQLITE_API int sqlite3session_patchset( + sqlite3_session *pSession, /* Session object */ + int *pnPatchset, /* OUT: Size of buffer at *ppPatchset */ + void **ppPatchset /* OUT: Buffer containing patchset */ +); + +/* +** CAPI3REF: Test if a changeset has recorded any changes. +** +** Return non-zero if no changes to attached tables have been recorded by +** the session object passed as the first argument. Otherwise, if one or +** more changes have been recorded, return zero. +** +** Even if this function returns zero, it is possible that calling +** [sqlite3session_changeset()] on the session handle may still return a +** changeset that contains no changes. This can happen when a row in +** an attached table is modified and then later on the original values +** are restored. However, if this function returns non-zero, then it is +** guaranteed that a call to sqlite3session_changeset() will return a +** changeset containing zero changes. +*/ +SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession); + +/* +** CAPI3REF: Query for the amount of heap memory used by a session object. +** +** This API returns the total amount of heap memory in bytes currently +** used by the session object passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession); + +/* +** CAPI3REF: Create An Iterator To Traverse A Changeset +** CONSTRUCTOR: sqlite3_changeset_iter +** +** Create an iterator used to iterate through the contents of a changeset. +** If successful, *pp is set to point to the iterator handle and SQLITE_OK +** is returned. Otherwise, if an error occurs, *pp is set to zero and an +** SQLite error code is returned. +** +** The following functions can be used to advance and query a changeset +** iterator created by this function: +** +**
    +**
  • [sqlite3changeset_next()] +**
  • [sqlite3changeset_op()] +**
  • [sqlite3changeset_new()] +**
  • [sqlite3changeset_old()] +**
+** +** It is the responsibility of the caller to eventually destroy the iterator +** by passing it to [sqlite3changeset_finalize()]. The buffer containing the +** changeset (pChangeset) must remain valid until after the iterator is +** destroyed. +** +** Assuming the changeset blob was created by one of the +** [sqlite3session_changeset()], [sqlite3changeset_concat()] or +** [sqlite3changeset_invert()] functions, all changes within the changeset +** that apply to a single table are grouped together. This means that when +** an application iterates through a changeset using an iterator created by +** this function, all changes that relate to a single table are visited +** consecutively. There is no chance that the iterator will visit a change +** the applies to table X, then one for table Y, and then later on visit +** another change for table X. +** +** The behavior of sqlite3changeset_start_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter. +** +** Note that the sqlite3changeset_start_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_start( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset /* Pointer to blob containing changeset */ +); +SQLITE_API int sqlite3changeset_start_v2( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset, /* Pointer to blob containing changeset */ + int flags /* SESSION_CHANGESETSTART_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_start_v2 +** +** The following flags may passed via the 4th parameter to +** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]: +** +**
SQLITE_CHANGESETAPPLY_INVERT
+** Invert the changeset while iterating through it. This is equivalent to +** inverting a changeset using sqlite3changeset_invert() before applying it. +** It is an error to specify this flag with a patchset. +*/ +#define SQLITE_CHANGESETSTART_INVERT 0x0002 + + +/* +** CAPI3REF: Advance A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function may only be used with iterators created by the function +** [sqlite3changeset_start()]. If it is called on an iterator passed to +** a conflict-handler callback by [sqlite3changeset_apply()], SQLITE_MISUSE +** is returned and the call has no effect. +** +** Immediately after an iterator is created by sqlite3changeset_start(), it +** does not point to any change in the changeset. Assuming the changeset +** is not empty, the first call to this function advances the iterator to +** point to the first change in the changeset. Each subsequent call advances +** the iterator to point to the next change in the changeset (if any). If +** no error occurs and the iterator points to a valid change after a call +** to sqlite3changeset_next() has advanced it, SQLITE_ROW is returned. +** Otherwise, if all changes in the changeset have already been visited, +** SQLITE_DONE is returned. +** +** If an error occurs, an SQLite error code is returned. Possible error +** codes include SQLITE_CORRUPT (if the changeset buffer is corrupt) or +** SQLITE_NOMEM. +*/ +SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Obtain The Current Operation From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this +** is not the case, this function returns [SQLITE_MISUSE]. +** +** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three +** outputs are set through these pointers: +** +** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the type of change that the iterator currently points to; +** +** *pnCol is set to the number of columns in the table affected by the change; and +** +** *pzTab is set to point to a nul-terminated utf-8 encoded string containing +** the name of the table affected by the current change. The buffer remains +** valid until either sqlite3changeset_next() is called on the iterator +** or until the conflict-handler function returns. +** +** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change +** is an indirect change, or false (0) otherwise. See the documentation for +** [sqlite3session_indirect()] for a description of direct and indirect +** changes. +** +** If no error occurs, SQLITE_OK is returned. If an error does occur, an +** SQLite error code is returned. The values of the output variables may not +** be trusted in this case. +*/ +SQLITE_API int sqlite3changeset_op( + sqlite3_changeset_iter *pIter, /* Iterator object */ + const char **pzTab, /* OUT: Pointer to table name */ + int *pnCol, /* OUT: Number of columns in table */ + int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */ + int *pbIndirect /* OUT: True for an 'indirect' change */ +); + +/* +** CAPI3REF: Obtain The Primary Key Definition Of A Table +** METHOD: sqlite3_changeset_iter +** +** For each modified table, a changeset includes the following: +** +**
    +**
  • The number of columns in the table, and +**
  • Which of those columns make up the tables PRIMARY KEY. +**
+** +** This function is used to find which columns comprise the PRIMARY KEY of +** the table modified by the change that iterator pIter currently points to. +** If successful, *pabPK is set to point to an array of nCol entries, where +** nCol is the number of columns in the table. Elements of *pabPK are set to +** 0x01 if the corresponding column is part of the tables primary key, or +** 0x00 if it is not. +** +** If argument pnCol is not NULL, then *pnCol is set to the number of columns +** in the table. +** +** If this function is called when the iterator does not point to a valid +** entry, SQLITE_MISUSE is returned and the output variables zeroed. Otherwise, +** SQLITE_OK is returned and the output variables populated as described +** above. +*/ +SQLITE_API int sqlite3changeset_pk( + sqlite3_changeset_iter *pIter, /* Iterator object */ + unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */ + int *pnCol /* OUT: Number of entries in output array */ +); + +/* +** CAPI3REF: Obtain old.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_DELETE] or [SQLITE_UPDATE]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** original row values stored as part of the UPDATE or DELETE change and +** returns SQLITE_OK. The name of the function comes from the fact that this +** is similar to the "old.*" columns available to update or delete triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_old( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain new.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_UPDATE] or [SQLITE_INSERT]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** new row values stored as part of the UPDATE or INSERT change and +** returns SQLITE_OK. If the change is an UPDATE and does not include +** a new value for the requested column, *ppValue is set to NULL and +** SQLITE_OK returned. The name of the function comes from the fact that +** this is similar to the "new.*" columns available to update or delete +** triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_new( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain Conflicting Row Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function should only be used with iterator objects passed to a +** conflict-handler callback by [sqlite3changeset_apply()] with either +** [SQLITE_CHANGESET_DATA] or [SQLITE_CHANGESET_CONFLICT]. If this function +** is called on any other iterator, [SQLITE_MISUSE] is returned and *ppValue +** is set to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the +** "conflicting row" associated with the current conflict-handler callback +** and returns SQLITE_OK. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_conflict( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Value from conflicting row */ +); + +/* +** CAPI3REF: Determine The Number Of Foreign Key Constraint Violations +** METHOD: sqlite3_changeset_iter +** +** This function may only be called with an iterator passed to an +** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case +** it sets the output variable to the total number of known foreign key +** violations in the destination database and returns SQLITE_OK. +** +** In all other cases this function returns SQLITE_MISUSE. +*/ +SQLITE_API int sqlite3changeset_fk_conflicts( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int *pnOut /* OUT: Number of FK violations */ +); + + +/* +** CAPI3REF: Finalize A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function is used to finalize an iterator allocated with +** [sqlite3changeset_start()]. +** +** This function should only be called on iterators created using the +** [sqlite3changeset_start()] function. If an application calls this +** function with an iterator passed to a conflict-handler by +** [sqlite3changeset_apply()], [SQLITE_MISUSE] is immediately returned and the +** call has no effect. +** +** If an error was encountered within a call to an sqlite3changeset_xxx() +** function (for example an [SQLITE_CORRUPT] in [sqlite3changeset_next()] or an +** [SQLITE_NOMEM] in [sqlite3changeset_new()]) then an error code corresponding +** to that error is returned by this function. Otherwise, SQLITE_OK is +** returned. This is to allow the following pattern (pseudo-code): +** +** 
+**   sqlite3changeset_start();
+**   while( SQLITE_ROW==sqlite3changeset_next() ){
+**     // Do something with change.
+**   }
+**   rc = sqlite3changeset_finalize();
+**   if( rc!=SQLITE_OK ){
+**     // An error has occurred
+**   }
+**
+*/ +SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Invert A Changeset +** +** This function is used to "invert" a changeset object. Applying an inverted +** changeset to a database reverses the effects of applying the uninverted +** changeset. Specifically: +** +**
    +**
  • Each DELETE change is changed to an INSERT, and +**
  • Each INSERT change is changed to a DELETE, and +**
  • For each UPDATE change, the old.* and new.* values are exchanged. +**
+** +** This function does not change the order in which changes appear within +** the changeset. It merely reverses the sense of each individual change. +** +** If successful, a pointer to a buffer containing the inverted changeset +** is stored in *ppOut, the size of the same buffer is stored in *pnOut, and +** SQLITE_OK is returned. If an error occurs, both *pnOut and *ppOut are +** zeroed and an SQLite error code returned. +** +** It is the responsibility of the caller to eventually call sqlite3_free() +** on the *ppOut pointer to free the buffer allocation following a successful +** call to this function. +** +** WARNING/TODO: This function currently assumes that the input is a valid +** changeset. If it is not, the results are undefined. +*/ +SQLITE_API int sqlite3changeset_invert( + int nIn, const void *pIn, /* Input changeset */ + int *pnOut, void **ppOut /* OUT: Inverse of input */ +); + +/* +** CAPI3REF: Concatenate Two Changeset Objects +** +** This function is used to concatenate two changesets, A and B, into a +** single changeset. The result is a changeset equivalent to applying +** changeset A followed by changeset B. +** +** This function combines the two input changesets using an +** sqlite3_changegroup object. Calling it produces similar results as the +** following code fragment: +** +** 
+**   sqlite3_changegroup *pGrp;
+**   rc = sqlite3_changegroup_new(&pGrp);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nB, pB);
+**   if( rc==SQLITE_OK ){
+**     rc = sqlite3changegroup_output(pGrp, pnOut, ppOut);
+**   }else{
+**     *ppOut = 0;
+**     *pnOut = 0;
+**   }
+**
+** +** Refer to the sqlite3_changegroup documentation below for details. +*/ +SQLITE_API int sqlite3changeset_concat( + int nA, /* Number of bytes in buffer pA */ + void *pA, /* Pointer to buffer containing changeset A */ + int nB, /* Number of bytes in buffer pB */ + void *pB, /* Pointer to buffer containing changeset B */ + int *pnOut, /* OUT: Number of bytes in output changeset */ + void **ppOut /* OUT: Buffer containing output changeset */ +); + + +/* +** CAPI3REF: Changegroup Handle +** +** A changegroup is an object used to combine two or more +** [changesets] or [patchsets] +*/ +typedef struct sqlite3_changegroup sqlite3_changegroup; + +/* +** CAPI3REF: Create A New Changegroup Object +** CONSTRUCTOR: sqlite3_changegroup +** +** An sqlite3_changegroup object is used to combine two or more changesets +** (or patchsets) into a single changeset (or patchset). A single changegroup +** object may combine changesets or patchsets, but not both. The output is +** always in the same format as the input. +** +** If successful, this function returns SQLITE_OK and populates (*pp) with +** a pointer to a new sqlite3_changegroup object before returning. The caller +** should eventually free the returned object using a call to +** sqlite3changegroup_delete(). If an error occurs, an SQLite error code +** (i.e. SQLITE_NOMEM) is returned and *pp is set to NULL. +** +** The usual usage pattern for an sqlite3_changegroup object is as follows: +** +**
    +**
  • It is created using a call to sqlite3changegroup_new(). +** +**
  • Zero or more changesets (or patchsets) are added to the object +** by calling sqlite3changegroup_add(). +** +**
  • The result of combining all input changesets together is obtained +** by the application via a call to sqlite3changegroup_output(). +** +**
  • The object is deleted using a call to sqlite3changegroup_delete(). +**
+** +** Any number of calls to add() and output() may be made between the calls to +** new() and delete(), and in any order. +** +** As well as the regular sqlite3changegroup_add() and +** sqlite3changegroup_output() functions, also available are the streaming +** versions sqlite3changegroup_add_strm() and sqlite3changegroup_output_strm(). +*/ +SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp); + +/* +** CAPI3REF: Add A Changeset To A Changegroup +** METHOD: sqlite3_changegroup +** +** Add all changes within the changeset (or patchset) in buffer pData (size +** nData bytes) to the changegroup. +** +** If the buffer contains a patchset, then all prior calls to this function +** on the same changegroup object must also have specified patchsets. Or, if +** the buffer contains a changeset, so must have the earlier calls to this +** function. Otherwise, SQLITE_ERROR is returned and no changes are added +** to the changegroup. +** +** Rows within the changeset and changegroup are identified by the values in +** their PRIMARY KEY columns. A change in the changeset is considered to +** apply to the same row as a change already present in the changegroup if +** the two rows have the same primary key. +** +** Changes to rows that do not already appear in the changegroup are +** simply copied into it. Or, if both the new changeset and the changegroup +** contain changes that apply to a single row, the final contents of the +** changegroup depends on the type of each change, as follows: +** +** +** +** +**
Existing Change New Change Output Change +**
INSERT INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
INSERT UPDATE +** The INSERT change remains in the changegroup. The values in the +** INSERT change are modified as if the row was inserted by the +** existing change and then updated according to the new change. +**
INSERT DELETE +** The existing INSERT is removed from the changegroup. The DELETE is +** not added. +**
UPDATE INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
UPDATE UPDATE +** The existing UPDATE remains within the changegroup. It is amended +** so that the accompanying values are as if the row was updated once +** by the existing change and then again by the new change. +**
UPDATE DELETE +** The existing UPDATE is replaced by the new DELETE within the +** changegroup. +**
DELETE INSERT +** If one or more of the column values in the row inserted by the +** new change differ from those in the row deleted by the existing +** change, the existing DELETE is replaced by an UPDATE within the +** changegroup. Otherwise, if the inserted row is exactly the same +** as the deleted row, the existing DELETE is simply discarded. +**
DELETE UPDATE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
DELETE DELETE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
+** +** If the new changeset contains changes to a table that is already present +** in the changegroup, then the number of columns and the position of the +** primary key columns for the table must be consistent. If this is not the +** case, this function fails with SQLITE_SCHEMA. If the input changeset +** appears to be corrupt and the corruption is detected, SQLITE_CORRUPT is +** returned. Or, if an out-of-memory condition occurs during processing, this +** function returns SQLITE_NOMEM. In all cases, if an error occurs the state +** of the final contents of the changegroup is undefined. +** +** If no error occurs, SQLITE_OK is returned. +*/ +SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData); + +/* +** CAPI3REF: Obtain A Composite Changeset From A Changegroup +** METHOD: sqlite3_changegroup +** +** Obtain a buffer containing a changeset (or patchset) representing the +** current contents of the changegroup. If the inputs to the changegroup +** were themselves changesets, the output is a changeset. Or, if the +** inputs were patchsets, the output is also a patchset. +** +** As with the output of the sqlite3session_changeset() and +** sqlite3session_patchset() functions, all changes related to a single +** table are grouped together in the output of this function. Tables appear +** in the same order as for the very first changeset added to the changegroup. +** If the second or subsequent changesets added to the changegroup contain +** changes for tables that do not appear in the first changeset, they are +** appended onto the end of the output changeset, again in the order in +** which they are first encountered. +** +** If an error occurs, an SQLite error code is returned and the output +** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK +** is returned and the output variables are set to the size of and a +** pointer to the output buffer, respectively. In this case it is the +** responsibility of the caller to eventually free the buffer using a +** call to sqlite3_free(). +*/ +SQLITE_API int sqlite3changegroup_output( + sqlite3_changegroup*, + int *pnData, /* OUT: Size of output buffer in bytes */ + void **ppData /* OUT: Pointer to output buffer */ +); + +/* +** CAPI3REF: Delete A Changegroup Object +** DESTRUCTOR: sqlite3_changegroup +*/ +SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*); + +/* +** CAPI3REF: Apply A Changeset To A Database +** +** Apply a changeset or patchset to a database. These functions attempt to +** update the "main" database attached to handle db with the changes found in +** the changeset passed via the second and third arguments. +** +** The fourth argument (xFilter) passed to these functions is the "filter +** callback". If it is not NULL, then for each table affected by at least one +** change in the changeset, the filter callback is invoked with +** the table name as the second argument, and a copy of the context pointer +** passed as the sixth argument as the first. If the "filter callback" +** returns zero, then no attempt is made to apply any changes to the table. +** Otherwise, if the return value is non-zero or the xFilter argument to +** is NULL, all changes related to the table are attempted. +** +** For each table that is not excluded by the filter callback, this function +** tests that the target database contains a compatible table. A table is +** considered compatible if all of the following are true: +** +**
    +**
  • The table has the same name as the name recorded in the +** changeset, and +**
  • The table has at least as many columns as recorded in the +** changeset, and +**
  • The table has primary key columns in the same position as +** recorded in the changeset. +**
+** +** If there is no compatible table, it is not an error, but none of the +** changes associated with the table are applied. A warning message is issued +** via the sqlite3_log() mechanism with the error code SQLITE_SCHEMA. At most +** one such warning is issued for each table in the changeset. +** +** For each change for which there is a compatible table, an attempt is made +** to modify the table contents according to the UPDATE, INSERT or DELETE +** change. If a change cannot be applied cleanly, the conflict handler +** function passed as the fifth argument to sqlite3changeset_apply() may be +** invoked. A description of exactly when the conflict handler is invoked for +** each type of change is below. +** +** Unlike the xFilter argument, xConflict may not be passed NULL. The results +** of passing anything other than a valid function pointer as the xConflict +** argument are undefined. +** +** Each time the conflict handler function is invoked, it must return one +** of [SQLITE_CHANGESET_OMIT], [SQLITE_CHANGESET_ABORT] or +** [SQLITE_CHANGESET_REPLACE]. SQLITE_CHANGESET_REPLACE may only be returned +** if the second argument passed to the conflict handler is either +** SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If the conflict-handler +** returns an illegal value, any changes already made are rolled back and +** the call to sqlite3changeset_apply() returns SQLITE_MISUSE. Different +** actions are taken by sqlite3changeset_apply() depending on the value +** returned by each invocation of the conflict-handler function. Refer to +** the documentation for the three +** [SQLITE_CHANGESET_OMIT|available return values] for details. +** +**
+**
DELETE Changes
+** For each DELETE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all non-primary key columns also match the values stored in +** the changeset the row is deleted from the target database. +** +** If a row with matching primary key values is found, but one or more of +** the non-primary key fields contains a value different from the original +** row value stored in the changeset, the conflict-handler function is +** invoked with [SQLITE_CHANGESET_DATA] as the second argument. If the +** database table has more columns than are recorded in the changeset, +** only the values of those non-primary key fields are compared against +** the current database contents - any trailing database table columns +** are ignored. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the DELETE operation is attempted, but SQLite returns SQLITE_CONSTRAINT +** (which can only happen if a foreign key constraint is violated), the +** conflict-handler function is invoked with [SQLITE_CHANGESET_CONSTRAINT] +** passed as the second argument. This includes the case where the DELETE +** operation is attempted because an earlier call to the conflict handler +** function returned [SQLITE_CHANGESET_REPLACE]. +** +**
INSERT Changes
+** For each INSERT change, an attempt is made to insert the new row into +** the database. If the changeset row contains fewer fields than the +** database table, the trailing fields are populated with their default +** values. +** +** If the attempt to insert the row fails because the database already +** contains a row with the same primary key values, the conflict handler +** function is invoked with the second argument set to +** [SQLITE_CHANGESET_CONFLICT]. +** +** If the attempt to insert the row fails because of some other constraint +** violation (e.g. NOT NULL or UNIQUE), the conflict handler function is +** invoked with the second argument set to [SQLITE_CHANGESET_CONSTRAINT]. +** This includes the case where the INSERT operation is re-attempted because +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +** +**
UPDATE Changes
+** For each UPDATE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all modified non-primary key columns also match the values +** stored in the changeset the row is updated within the target database. +** +** If a row with matching primary key values is found, but one or more of +** the modified non-primary key fields contains a value different from an +** original row value stored in the changeset, the conflict-handler function +** is invoked with [SQLITE_CHANGESET_DATA] as the second argument. Since +** UPDATE changes only contain values for non-primary key fields that are +** to be modified, only those fields need to match the original values to +** avoid the SQLITE_CHANGESET_DATA conflict-handler callback. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the UPDATE operation is attempted, but SQLite returns +** SQLITE_CONSTRAINT, the conflict-handler function is invoked with +** [SQLITE_CHANGESET_CONSTRAINT] passed as the second argument. +** This includes the case where the UPDATE operation is attempted after +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +**
+** +** It is safe to execute SQL statements, including those that write to the +** table that the callback related to, from within the xConflict callback. +** This can be used to further customize the application's conflict +** resolution strategy. +** +** All changes made by these functions are enclosed in a savepoint transaction. +** If any other error (aside from a constraint failure when attempting to +** write to the target database) occurs, then the savepoint transaction is +** rolled back, restoring the target database to its original state, and an +** SQLite error code returned. +** +** If the output parameters (ppRebase) and (pnRebase) are non-NULL and +** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2() +** may set (*ppRebase) to point to a "rebase" that may be used with the +** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase) +** is set to the size of the buffer in bytes. It is the responsibility of the +** caller to eventually free any such buffer using sqlite3_free(). The buffer +** is only allocated and populated if one or more conflicts were encountered +** while applying the patchset. See comments surrounding the sqlite3_rebaser +** APIs for further details. +** +** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter. +** +** Note that the sqlite3changeset_apply_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_apply( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, /* OUT: Rebase data */ + int flags /* SESSION_CHANGESETAPPLY_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_apply_v2 +** +** The following flags may passed via the 9th parameter to +** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]: +** +**
+**
SQLITE_CHANGESETAPPLY_NOSAVEPOINT
+** Usually, the sessions module encloses all operations performed by +** a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The +** SAVEPOINT is committed if the changeset or patchset is successfully +** applied, or rolled back if an error occurs. Specifying this flag +** causes the sessions module to omit this savepoint. In this case, if the +** caller has an open transaction or savepoint when apply_v2() is called, +** it may revert the partially applied changeset by rolling it back. +** +**
SQLITE_CHANGESETAPPLY_INVERT
+** Invert the changeset before applying it. This is equivalent to inverting +** a changeset using sqlite3changeset_invert() before applying it. It is +** an error to specify this flag with a patchset. +*/ +#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT 0x0001 +#define SQLITE_CHANGESETAPPLY_INVERT 0x0002 + +/* +** CAPI3REF: Constants Passed To The Conflict Handler +** +** Values that may be passed as the second argument to a conflict-handler. +** +**
+**
SQLITE_CHANGESET_DATA
+** The conflict handler is invoked with CHANGESET_DATA as the second argument +** when processing a DELETE or UPDATE change if a row with the required +** PRIMARY KEY fields is present in the database, but one or more other +** (non primary-key) fields modified by the update do not contain the +** expected "before" values. +** +** The conflicting row, in this case, is the database row with the matching +** primary key. +** +**
SQLITE_CHANGESET_NOTFOUND
+** The conflict handler is invoked with CHANGESET_NOTFOUND as the second +** argument when processing a DELETE or UPDATE change if a row with the +** required PRIMARY KEY fields is not present in the database. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
SQLITE_CHANGESET_CONFLICT
+** CHANGESET_CONFLICT is passed as the second argument to the conflict +** handler while processing an INSERT change if the operation would result +** in duplicate primary key values. +** +** The conflicting row in this case is the database row with the matching +** primary key. +** +**
SQLITE_CHANGESET_FOREIGN_KEY
+** If foreign key handling is enabled, and applying a changeset leaves the +** database in a state containing foreign key violations, the conflict +** handler is invoked with CHANGESET_FOREIGN_KEY as the second argument +** exactly once before the changeset is committed. If the conflict handler +** returns CHANGESET_OMIT, the changes, including those that caused the +** foreign key constraint violation, are committed. Or, if it returns +** CHANGESET_ABORT, the changeset is rolled back. +** +** No current or conflicting row information is provided. The only function +** it is possible to call on the supplied sqlite3_changeset_iter handle +** is sqlite3changeset_fk_conflicts(). +** +**
SQLITE_CHANGESET_CONSTRAINT
+** If any other constraint violation occurs while applying a change (i.e. +** a UNIQUE, CHECK or NOT NULL constraint), the conflict handler is +** invoked with CHANGESET_CONSTRAINT as the second argument. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
+*/ +#define SQLITE_CHANGESET_DATA 1 +#define SQLITE_CHANGESET_NOTFOUND 2 +#define SQLITE_CHANGESET_CONFLICT 3 +#define SQLITE_CHANGESET_CONSTRAINT 4 +#define SQLITE_CHANGESET_FOREIGN_KEY 5 + +/* +** CAPI3REF: Constants Returned By The Conflict Handler +** +** A conflict handler callback must return one of the following three values. +** +**
+**
SQLITE_CHANGESET_OMIT
+** If a conflict handler returns this value no special action is taken. The +** change that caused the conflict is not applied. The session module +** continues to the next change in the changeset. +** +**
SQLITE_CHANGESET_REPLACE
+** This value may only be returned if the second argument to the conflict +** handler was SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If this +** is not the case, any changes applied so far are rolled back and the +** call to sqlite3changeset_apply() returns SQLITE_MISUSE. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_DATA conflict +** handler, then the conflicting row is either updated or deleted, depending +** on the type of change. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_CONFLICT conflict +** handler, then the conflicting row is removed from the database and a +** second attempt to apply the change is made. If this second attempt fails, +** the original row is restored to the database before continuing. +** +**
SQLITE_CHANGESET_ABORT
+** If this value is returned, any changes applied so far are rolled back +** and the call to sqlite3changeset_apply() returns SQLITE_ABORT. +**
+*/ +#define SQLITE_CHANGESET_OMIT 0 +#define SQLITE_CHANGESET_REPLACE 1 +#define SQLITE_CHANGESET_ABORT 2 + +/* +** CAPI3REF: Rebasing changesets +** EXPERIMENTAL +** +** Suppose there is a site hosting a database in state S0. And that +** modifications are made that move that database to state S1 and a +** changeset recorded (the "local" changeset). Then, a changeset based +** on S0 is received from another site (the "remote" changeset) and +** applied to the database. The database is then in state +** (S1+"remote"), where the exact state depends on any conflict +** resolution decisions (OMIT or REPLACE) made while applying "remote". +** Rebasing a changeset is to update it to take those conflict +** resolution decisions into account, so that the same conflicts +** do not have to be resolved elsewhere in the network. +** +** For example, if both the local and remote changesets contain an +** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)": +** +** local: INSERT INTO t1 VALUES(1, 'v1'); +** remote: INSERT INTO t1 VALUES(1, 'v2'); +** +** and the conflict resolution is REPLACE, then the INSERT change is +** removed from the local changeset (it was overridden). Or, if the +** conflict resolution was "OMIT", then the local changeset is modified +** to instead contain: +** +** UPDATE t1 SET b = 'v2' WHERE a=1; +** +** Changes within the local changeset are rebased as follows: +** +**
+**
Local INSERT
+** This may only conflict with a remote INSERT. If the conflict +** resolution was OMIT, then add an UPDATE change to the rebased +** changeset. Or, if the conflict resolution was REPLACE, add +** nothing to the rebased changeset. +** +**
Local DELETE
+** This may conflict with a remote UPDATE or DELETE. In both cases the +** only possible resolution is OMIT. If the remote operation was a +** DELETE, then add no change to the rebased changeset. If the remote +** operation was an UPDATE, then the old.* fields of change are updated +** to reflect the new.* values in the UPDATE. +** +**
Local UPDATE
+** This may conflict with a remote UPDATE or DELETE. If it conflicts +** with a DELETE, and the conflict resolution was OMIT, then the update +** is changed into an INSERT. Any undefined values in the new.* record +** from the update change are filled in using the old.* values from +** the conflicting DELETE. Or, if the conflict resolution was REPLACE, +** the UPDATE change is simply omitted from the rebased changeset. +** +** If conflict is with a remote UPDATE and the resolution is OMIT, then +** the old.* values are rebased using the new.* values in the remote +** change. Or, if the resolution is REPLACE, then the change is copied +** into the rebased changeset with updates to columns also updated by +** the conflicting remote UPDATE removed. If this means no columns would +** be updated, the change is omitted. +**
+** +** A local change may be rebased against multiple remote changes +** simultaneously. If a single key is modified by multiple remote +** changesets, they are combined as follows before the local changeset +** is rebased: +** +**
    +**
  • If there has been one or more REPLACE resolutions on a +** key, it is rebased according to a REPLACE. +** +**
  • If there have been no REPLACE resolutions on a key, then +** the local changeset is rebased according to the most recent +** of the OMIT resolutions. +**
+** +** Note that conflict resolutions from multiple remote changesets are +** combined on a per-field basis, not per-row. This means that in the +** case of multiple remote UPDATE operations, some fields of a single +** local change may be rebased for REPLACE while others are rebased for +** OMIT. +** +** In order to rebase a local changeset, the remote changeset must first +** be applied to the local database using sqlite3changeset_apply_v2() and +** the buffer of rebase information captured. Then: +** +**
    +**
  1. An sqlite3_rebaser object is created by calling +** sqlite3rebaser_create(). +**
  2. The new object is configured with the rebase buffer obtained from +** sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure(). +** If the local changeset is to be rebased against multiple remote +** changesets, then sqlite3rebaser_configure() should be called +** multiple times, in the same order that the multiple +** sqlite3changeset_apply_v2() calls were made. +**
  3. Each local changeset is rebased by calling sqlite3rebaser_rebase(). +**
  4. The sqlite3_rebaser object is deleted by calling +** sqlite3rebaser_delete(). +**
+*/ +typedef struct sqlite3_rebaser sqlite3_rebaser; + +/* +** CAPI3REF: Create a changeset rebaser object. +** EXPERIMENTAL +** +** Allocate a new changeset rebaser object. If successful, set (*ppNew) to +** point to the new object and return SQLITE_OK. Otherwise, if an error +** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew) +** to NULL. +*/ +SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew); + +/* +** CAPI3REF: Configure a changeset rebaser object. +** EXPERIMENTAL +** +** Configure the changeset rebaser object to rebase changesets according +** to the conflict resolutions described by buffer pRebase (size nRebase +** bytes), which must have been obtained from a previous call to +** sqlite3changeset_apply_v2(). +*/ +SQLITE_API int sqlite3rebaser_configure( + sqlite3_rebaser*, + int nRebase, const void *pRebase +); + +/* +** CAPI3REF: Rebase a changeset +** EXPERIMENTAL +** +** Argument pIn must point to a buffer containing a changeset nIn bytes +** in size. This function allocates and populates a buffer with a copy +** of the changeset rebased according to the configuration of the +** rebaser object passed as the first argument. If successful, (*ppOut) +** is set to point to the new buffer containing the rebased changeset and +** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the +** responsibility of the caller to eventually free the new buffer using +** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut) +** are set to zero and an SQLite error code returned. +*/ +SQLITE_API int sqlite3rebaser_rebase( + sqlite3_rebaser*, + int nIn, const void *pIn, + int *pnOut, void **ppOut +); + +/* +** CAPI3REF: Delete a changeset rebaser object. +** EXPERIMENTAL +** +** Delete the changeset rebaser object and all associated resources. There +** should be one call to this function for each successful invocation +** of sqlite3rebaser_create(). +*/ +SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p); + +/* +** CAPI3REF: Streaming Versions of API functions. +** +** The six streaming API xxx_strm() functions serve similar purposes to the +** corresponding non-streaming API functions: +** +** +** +**
Streaming functionNon-streaming equivalent
sqlite3changeset_apply_strm[sqlite3changeset_apply] +**
sqlite3changeset_apply_strm_v2[sqlite3changeset_apply_v2] +**
sqlite3changeset_concat_strm[sqlite3changeset_concat] +**
sqlite3changeset_invert_strm[sqlite3changeset_invert] +**
sqlite3changeset_start_strm[sqlite3changeset_start] +**
sqlite3session_changeset_strm[sqlite3session_changeset] +**
sqlite3session_patchset_strm[sqlite3session_patchset] +**
+** +** Non-streaming functions that accept changesets (or patchsets) as input +** require that the entire changeset be stored in a single buffer in memory. +** Similarly, those that return a changeset or patchset do so by returning +** a pointer to a single large buffer allocated using sqlite3_malloc(). +** Normally this is convenient. However, if an application running in a +** low-memory environment is required to handle very large changesets, the +** large contiguous memory allocations required can become onerous. +** +** In order to avoid this problem, instead of a single large buffer, input +** is passed to a streaming API functions by way of a callback function that +** the sessions module invokes to incrementally request input data as it is +** required. In all cases, a pair of API function parameters such as +** +** 
+**        int nChangeset,
+**        void *pChangeset,
+**
+** +** Is replaced by: +** +** 
+**        int (*xInput)(void *pIn, void *pData, int *pnData),
+**        void *pIn,
+**
+** +** Each time the xInput callback is invoked by the sessions module, the first +** argument passed is a copy of the supplied pIn context pointer. The second +** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no +** error occurs the xInput method should copy up to (*pnData) bytes of data +** into the buffer and set (*pnData) to the actual number of bytes copied +** before returning SQLITE_OK. If the input is completely exhausted, (*pnData) +** should be set to zero to indicate this. Or, if an error occurs, an SQLite +** error code should be returned. In all cases, if an xInput callback returns +** an error, all processing is abandoned and the streaming API function +** returns a copy of the error code to the caller. +** +** In the case of sqlite3changeset_start_strm(), the xInput callback may be +** invoked by the sessions module at any point during the lifetime of the +** iterator. If such an xInput callback returns an error, the iterator enters +** an error state, whereby all subsequent calls to iterator functions +** immediately fail with the same error code as returned by xInput. +** +** Similarly, streaming API functions that return changesets (or patchsets) +** return them in chunks by way of a callback function instead of via a +** pointer to a single large buffer. In this case, a pair of parameters such +** as: +** +** 
+**        int *pnChangeset,
+**        void **ppChangeset,
+**
+** +** Is replaced by: +** +** 
+**        int (*xOutput)(void *pOut, const void *pData, int nData),
+**        void *pOut
+**
+** +** The xOutput callback is invoked zero or more times to return data to +** the application. The first parameter passed to each call is a copy of the +** pOut pointer supplied by the application. The second parameter, pData, +** points to a buffer nData bytes in size containing the chunk of output +** data being returned. If the xOutput callback successfully processes the +** supplied data, it should return SQLITE_OK to indicate success. Otherwise, +** it should return some other SQLite error code. In this case processing +** is immediately abandoned and the streaming API function returns a copy +** of the xOutput error code to the application. +** +** The sessions module never invokes an xOutput callback with the third +** parameter set to a value less than or equal to zero. Other than this, +** no guarantees are made as to the size of the chunks of data returned. +*/ +SQLITE_API int sqlite3changeset_apply_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, + int flags +); +SQLITE_API int sqlite3changeset_concat_strm( + int (*xInputA)(void *pIn, void *pData, int *pnData), + void *pInA, + int (*xInputB)(void *pIn, void *pData, int *pnData), + void *pInB, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_invert_strm( + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_start_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changeset_start_v2_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int flags +); +SQLITE_API int sqlite3session_changeset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3session_patchset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changegroup_add_strm(sqlite3_changegroup*, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changegroup_output_strm(sqlite3_changegroup*, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3rebaser_rebase_strm( + sqlite3_rebaser *pRebaser, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); + +/* +** CAPI3REF: Configure global parameters +** +** The sqlite3session_config() interface is used to make global configuration +** changes to the sessions module in order to tune it to the specific needs +** of the application. +** +** The sqlite3session_config() interface is not threadsafe. If it is invoked +** while any other thread is inside any other sessions method then the +** results are undefined. Furthermore, if it is invoked after any sessions +** related objects have been created, the results are also undefined. +** +** The first argument to the sqlite3session_config() function must be one +** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The +** interpretation of the (void*) value passed as the second parameter and +** the effect of calling this function depends on the value of the first +** parameter. +** +**
+**
SQLITE_SESSION_CONFIG_STRMSIZE
+** By default, the sessions module streaming interfaces attempt to input +** and output data in approximately 1 KiB chunks. This operand may be used +** to set and query the value of this configuration setting. The pointer +** passed as the second argument must point to a value of type (int). +** If this value is greater than 0, it is used as the new streaming data +** chunk size for both input and output. Before returning, the (int) value +** pointed to by pArg is set to the final value of the streaming interface +** chunk size. +**
+** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +SQLITE_API int sqlite3session_config(int op, void *pArg); + +/* +** CAPI3REF: Values for sqlite3session_config(). +*/ +#define SQLITE_SESSION_CONFIG_STRMSIZE 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +} +#endif + +#endif /* !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) */ + +/******** End of sqlite3session.h *********/ +/******** Begin file fts5.h *********/ +/* +** 2014 May 31 +** +** 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. +** +****************************************************************************** +** +** Interfaces to extend FTS5. Using the interfaces defined in this file, +** FTS5 may be extended with: +** +** * custom tokenizers, and +** * custom auxiliary functions. +*/ + + +#ifndef _FTS5_H +#define _FTS5_H + + +#ifdef __cplusplus +extern "C" { +#endif + +/************************************************************************* +** CUSTOM AUXILIARY FUNCTIONS +** +** Virtual table implementations may overload SQL functions by implementing +** the sqlite3_module.xFindFunction() method. +*/ + +typedef struct Fts5ExtensionApi Fts5ExtensionApi; +typedef struct Fts5Context Fts5Context; +typedef struct Fts5PhraseIter Fts5PhraseIter; + +typedef void (*fts5_extension_function)( + const Fts5ExtensionApi *pApi, /* API offered by current FTS version */ + Fts5Context *pFts, /* First arg to pass to pApi functions */ + sqlite3_context *pCtx, /* Context for returning result/error */ + int nVal, /* Number of values in apVal[] array */ + sqlite3_value **apVal /* Array of trailing arguments */ +); + +struct Fts5PhraseIter { + const unsigned char *a; + const unsigned char *b; +}; + +/* +** EXTENSION API FUNCTIONS +** +** xUserData(pFts): +** Return a copy of the context pointer the extension function was +** registered with. +** +** xColumnTotalSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the FTS5 table. Or, if iCol is +** non-negative but less than the number of columns in the table, return +** the total number of tokens in column iCol, considering all rows in +** the FTS5 table. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** xColumnCount(pFts): +** Return the number of columns in the table. +** +** xColumnSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the current row. Or, if iCol is +** non-negative but less than the number of columns in the table, set +** *pnToken to the number of tokens in column iCol of the current row. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** This function may be quite inefficient if used with an FTS5 table +** created with the "columnsize=0" option. +** +** xColumnText: +** This function attempts to retrieve the text of column iCol of the +** current document. If successful, (*pz) is set to point to a buffer +** containing the text in utf-8 encoding, (*pn) is set to the size in bytes +** (not characters) of the buffer and SQLITE_OK is returned. Otherwise, +** if an error occurs, an SQLite error code is returned and the final values +** of (*pz) and (*pn) are undefined. +** +** xPhraseCount: +** Returns the number of phrases in the current query expression. +** +** xPhraseSize: +** Returns the number of tokens in phrase iPhrase of the query. Phrases +** are numbered starting from zero. +** +** xInstCount: +** Set *pnInst to the total number of occurrences of all phrases within +** the query within the current row. Return SQLITE_OK if successful, or +** an error code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always returns 0. +** +** xInst: +** Query for the details of phrase match iIdx within the current row. +** Phrase matches are numbered starting from zero, so the iIdx argument +** should be greater than or equal to zero and smaller than the value +** output by xInstCount(). +** +** Usually, output parameter *piPhrase is set to the phrase number, *piCol +** to the column in which it occurs and *piOff the token offset of the +** first token of the phrase. Returns SQLITE_OK if successful, or an error +** code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. +** +** xRowid: +** Returns the rowid of the current row. +** +** xTokenize: +** Tokenize text using the tokenizer belonging to the FTS5 table. +** +** xQueryPhrase(pFts5, iPhrase, pUserData, xCallback): +** This API function is used to query the FTS table for phrase iPhrase +** of the current query. Specifically, a query equivalent to: +** +** ... FROM ftstable WHERE ftstable MATCH $p ORDER BY rowid +** +** with $p set to a phrase equivalent to the phrase iPhrase of the +** current query is executed. Any column filter that applies to +** phrase iPhrase of the current query is included in $p. For each +** row visited, the callback function passed as the fourth argument +** is invoked. The context and API objects passed to the callback +** function may be used to access the properties of each matched row. +** Invoking Api.xUserData() returns a copy of the pointer passed as +** the third argument to pUserData. +** +** If the callback function returns any value other than SQLITE_OK, the +** query is abandoned and the xQueryPhrase function returns immediately. +** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK. +** Otherwise, the error code is propagated upwards. +** +** If the query runs to completion without incident, SQLITE_OK is returned. +** Or, if some error occurs before the query completes or is aborted by +** the callback, an SQLite error code is returned. +** +** +** xSetAuxdata(pFts5, pAux, xDelete) +** +** Save the pointer passed as the second argument as the extension function's +** "auxiliary data". The pointer may then be retrieved by the current or any +** future invocation of the same fts5 extension function made as part of +** the same MATCH query using the xGetAuxdata() API. +** +** Each extension function is allocated a single auxiliary data slot for +** each FTS query (MATCH expression). If the extension function is invoked +** more than once for a single FTS query, then all invocations share a +** single auxiliary data context. +** +** If there is already an auxiliary data pointer when this function is +** invoked, then it is replaced by the new pointer. If an xDelete callback +** was specified along with the original pointer, it is invoked at this +** point. +** +** The xDelete callback, if one is specified, is also invoked on the +** auxiliary data pointer after the FTS5 query has finished. +** +** If an error (e.g. an OOM condition) occurs within this function, +** the auxiliary data is set to NULL and an error code returned. If the +** xDelete parameter was not NULL, it is invoked on the auxiliary data +** pointer before returning. +** +** +** xGetAuxdata(pFts5, bClear) +** +** Returns the current auxiliary data pointer for the fts5 extension +** function. See the xSetAuxdata() method for details. +** +** If the bClear argument is non-zero, then the auxiliary data is cleared +** (set to NULL) before this function returns. In this case the xDelete, +** if any, is not invoked. +** +** +** xRowCount(pFts5, pnRow) +** +** This function is used to retrieve the total number of rows in the table. +** In other words, the same value that would be returned by: +** +** SELECT count(*) FROM ftstable; +** +** xPhraseFirst() +** This function is used, along with type Fts5PhraseIter and the xPhraseNext +** method, to iterate through all instances of a single query phrase within +** the current row. This is the same information as is accessible via the +** xInstCount/xInst APIs. While the xInstCount/xInst APIs are more convenient +** to use, this API may be faster under some circumstances. To iterate +** through instances of phrase iPhrase, use the following code: +** +** Fts5PhraseIter iter; +** int iCol, iOff; +** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff); +** iCol>=0; +** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff) +** ){ +** // An instance of phrase iPhrase at offset iOff of column iCol +** } +** +** The Fts5PhraseIter structure is defined above. Applications should not +** modify this structure directly - it should only be used as shown above +** with the xPhraseFirst() and xPhraseNext() API methods (and by +** xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below). +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always iterates +** through an empty set (all calls to xPhraseFirst() set iCol to -1). +** +** xPhraseNext() +** See xPhraseFirst above. +** +** xPhraseFirstColumn() +** This function and xPhraseNextColumn() are similar to the xPhraseFirst() +** and xPhraseNext() APIs described above. The difference is that instead +** of iterating through all instances of a phrase in the current row, these +** APIs are used to iterate through the set of columns in the current row +** that contain one or more instances of a specified phrase. For example: +** +** Fts5PhraseIter iter; +** int iCol; +** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol); +** iCol>=0; +** pApi->xPhraseNextColumn(pFts, &iter, &iCol) +** ){ +** // Column iCol contains at least one instance of phrase iPhrase +** } +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" option. If the FTS5 table is created with either +** "detail=none" "content=" option (i.e. if it is a contentless table), +** then this API always iterates through an empty set (all calls to +** xPhraseFirstColumn() set iCol to -1). +** +** The information accessed using this API and its companion +** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext +** (or xInst/xInstCount). The chief advantage of this API is that it is +** significantly more efficient than those alternatives when used with +** "detail=column" tables. +** +** xPhraseNextColumn() +** See xPhraseFirstColumn above. +*/ +struct Fts5ExtensionApi { + int iVersion; /* Currently always set to 3 */ + + void *(*xUserData)(Fts5Context*); + + int (*xColumnCount)(Fts5Context*); + int (*xRowCount)(Fts5Context*, sqlite3_int64 *pnRow); + int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken); + + int (*xTokenize)(Fts5Context*, + const char *pText, int nText, /* Text to tokenize */ + void *pCtx, /* Context passed to xToken() */ + int (*xToken)(void*, int, const char*, int, int, int) /* Callback */ + ); + + int (*xPhraseCount)(Fts5Context*); + int (*xPhraseSize)(Fts5Context*, int iPhrase); + + int (*xInstCount)(Fts5Context*, int *pnInst); + int (*xInst)(Fts5Context*, int iIdx, int *piPhrase, int *piCol, int *piOff); + + sqlite3_int64 (*xRowid)(Fts5Context*); + int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn); + int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken); + + int (*xQueryPhrase)(Fts5Context*, int iPhrase, void *pUserData, + int(*)(const Fts5ExtensionApi*,Fts5Context*,void*) + ); + int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*)); + void *(*xGetAuxdata)(Fts5Context*, int bClear); + + int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*); + void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff); + + int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*); + void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol); +}; + +/* +** CUSTOM AUXILIARY FUNCTIONS +*************************************************************************/ + +/************************************************************************* +** CUSTOM TOKENIZERS +** +** Applications may also register custom tokenizer types. A tokenizer +** is registered by providing fts5 with a populated instance of the +** following structure. All structure methods must be defined, setting +** any member of the fts5_tokenizer struct to NULL leads to undefined +** behaviour. The structure methods are expected to function as follows: +** +** xCreate: +** This function is used to allocate and initialize a tokenizer instance. +** A tokenizer instance is required to actually tokenize text. +** +** The first argument passed to this function is a copy of the (void*) +** pointer provided by the application when the fts5_tokenizer object +** was registered with FTS5 (the third argument to xCreateTokenizer()). +** The second and third arguments are an array of nul-terminated strings +** containing the tokenizer arguments, if any, specified following the +** tokenizer name as part of the CREATE VIRTUAL TABLE statement used +** to create the FTS5 table. +** +** The final argument is an output variable. If successful, (*ppOut) +** should be set to point to the new tokenizer handle and SQLITE_OK +** returned. If an error occurs, some value other than SQLITE_OK should +** be returned. In this case, fts5 assumes that the final value of *ppOut +** is undefined. +** +** xDelete: +** This function is invoked to delete a tokenizer handle previously +** allocated using xCreate(). Fts5 guarantees that this function will +** be invoked exactly once for each successful call to xCreate(). +** +** xTokenize: +** This function is expected to tokenize the nText byte string indicated +** by argument pText. pText may or may not be nul-terminated. The first +** argument passed to this function is a pointer to an Fts5Tokenizer object +** returned by an earlier call to xCreate(). +** +** The second argument indicates the reason that FTS5 is requesting +** tokenization of the supplied text. This is always one of the following +** four values: +** +**
  • FTS5_TOKENIZE_DOCUMENT - A document is being inserted into +** or removed from the FTS table. The tokenizer is being invoked to +** determine the set of tokens to add to (or delete from) the +** FTS index. +** +**
  • FTS5_TOKENIZE_QUERY - A MATCH query is being executed +** against the FTS index. The tokenizer is being called to tokenize +** a bareword or quoted string specified as part of the query. +** +**
  • (FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX) - Same as +** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is +** followed by a "*" character, indicating that the last token +** returned by the tokenizer will be treated as a token prefix. +** +**
  • FTS5_TOKENIZE_AUX - The tokenizer is being invoked to +** satisfy an fts5_api.xTokenize() request made by an auxiliary +** function. Or an fts5_api.xColumnSize() request made by the same +** on a columnsize=0 database. +**
+** +** For each token in the input string, the supplied callback xToken() must +** be invoked. The first argument to it should be a copy of the pointer +** passed as the second argument to xTokenize(). The third and fourth +** arguments are a pointer to a buffer containing the token text, and the +** size of the token in bytes. The 4th and 5th arguments are the byte offsets +** of the first byte of and first byte immediately following the text from +** which the token is derived within the input. +** +** The second argument passed to the xToken() callback ("tflags") should +** normally be set to 0. The exception is if the tokenizer supports +** synonyms. In this case see the discussion below for details. +** +** FTS5 assumes the xToken() callback is invoked for each token in the +** order that they occur within the input text. +** +** If an xToken() callback returns any value other than SQLITE_OK, then +** the tokenization should be abandoned and the xTokenize() method should +** immediately return a copy of the xToken() return value. Or, if the +** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally, +** if an error occurs with the xTokenize() implementation itself, it +** may abandon the tokenization and return any error code other than +** SQLITE_OK or SQLITE_DONE. +** +** SYNONYM SUPPORT +** +** Custom tokenizers may also support synonyms. Consider a case in which a +** user wishes to query for a phrase such as "first place". Using the +** built-in tokenizers, the FTS5 query 'first + place' will match instances +** of "first place" within the document set, but not alternative forms +** such as "1st place". In some applications, it would be better to match +** all instances of "first place" or "1st place" regardless of which form +** the user specified in the MATCH query text. +** +** There are several ways to approach this in FTS5: +** +**
  1. By mapping all synonyms to a single token. In this case, using +** the above example, this means that the tokenizer returns the +** same token for inputs "first" and "1st". Say that token is in +** fact "first", so that when the user inserts the document "I won +** 1st place" entries are added to the index for tokens "i", "won", +** "first" and "place". If the user then queries for '1st + place', +** the tokenizer substitutes "first" for "1st" and the query works +** as expected. +** +**
  2. By querying the index for all synonyms of each query term +** separately. In this case, when tokenizing query text, the +** tokenizer may provide multiple synonyms for a single term +** within the document. FTS5 then queries the index for each +** synonym individually. For example, faced with the query: +** +** +** ... MATCH 'first place' +** +** the tokenizer offers both "1st" and "first" as synonyms for the +** first token in the MATCH query and FTS5 effectively runs a query +** similar to: +** +** +** ... MATCH '(first OR 1st) place' +** +** except that, for the purposes of auxiliary functions, the query +** still appears to contain just two phrases - "(first OR 1st)" +** being treated as a single phrase. +** +**
  3. By adding multiple synonyms for a single term to the FTS index. +** Using this method, when tokenizing document text, the tokenizer +** provides multiple synonyms for each token. So that when a +** document such as "I won first place" is tokenized, entries are +** added to the FTS index for "i", "won", "first", "1st" and +** "place". +** +** This way, even if the tokenizer does not provide synonyms +** when tokenizing query text (it should not - to do so would be +** inefficient), it doesn't matter if the user queries for +** 'first + place' or '1st + place', as there are entries in the +** FTS index corresponding to both forms of the first token. +**
+** +** Whether it is parsing document or query text, any call to xToken that +** specifies a tflags argument with the FTS5_TOKEN_COLOCATED bit +** is considered to supply a synonym for the previous token. For example, +** when parsing the document "I won first place", a tokenizer that supports +** synonyms would call xToken() 5 times, as follows: +** +** +** xToken(pCtx, 0, "i", 1, 0, 1); +** xToken(pCtx, 0, "won", 3, 2, 5); +** xToken(pCtx, 0, "first", 5, 6, 11); +** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11); +** xToken(pCtx, 0, "place", 5, 12, 17); +** +** +** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time +** xToken() is called. Multiple synonyms may be specified for a single token +** by making multiple calls to xToken(FTS5_TOKEN_COLOCATED) in sequence. +** There is no limit to the number of synonyms that may be provided for a +** single token. +** +** In many cases, method (1) above is the best approach. It does not add +** extra data to the FTS index or require FTS5 to query for multiple terms, +** so it is efficient in terms of disk space and query speed. However, it +** does not support prefix queries very well. If, as suggested above, the +** token "first" is substituted for "1st" by the tokenizer, then the query: +** +** +** ... MATCH '1s*' +** +** will not match documents that contain the token "1st" (as the tokenizer +** will probably not map "1s" to any prefix of "first"). +** +** For full prefix support, method (3) may be preferred. In this case, +** because the index contains entries for both "first" and "1st", prefix +** queries such as 'fi*' or '1s*' will match correctly. However, because +** extra entries are added to the FTS index, this method uses more space +** within the database. +** +** Method (2) offers a midpoint between (1) and (3). Using this method, +** a query such as '1s*' will match documents that contain the literal +** token "1st", but not "first" (assuming the tokenizer is not able to +** provide synonyms for prefixes). However, a non-prefix query like '1st' +** will match against "1st" and "first". This method does not require +** extra disk space, as no extra entries are added to the FTS index. +** On the other hand, it may require more CPU cycles to run MATCH queries, +** as separate queries of the FTS index are required for each synonym. +** +** When using methods (2) or (3), it is important that the tokenizer only +** provide synonyms when tokenizing document text (method (2)) or query +** text (method (3)), not both. Doing so will not cause any errors, but is +** inefficient. +*/ +typedef struct Fts5Tokenizer Fts5Tokenizer; +typedef struct fts5_tokenizer fts5_tokenizer; +struct fts5_tokenizer { + int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut); + void (*xDelete)(Fts5Tokenizer*); + int (*xTokenize)(Fts5Tokenizer*, + void *pCtx, + int flags, /* Mask of FTS5_TOKENIZE_* flags */ + const char *pText, int nText, + int (*xToken)( + void *pCtx, /* Copy of 2nd argument to xTokenize() */ + int tflags, /* Mask of FTS5_TOKEN_* flags */ + const char *pToken, /* Pointer to buffer containing token */ + int nToken, /* Size of token in bytes */ + int iStart, /* Byte offset of token within input text */ + int iEnd /* Byte offset of end of token within input text */ + ) + ); +}; + +/* Flags that may be passed as the third argument to xTokenize() */ +#define FTS5_TOKENIZE_QUERY 0x0001 +#define FTS5_TOKENIZE_PREFIX 0x0002 +#define FTS5_TOKENIZE_DOCUMENT 0x0004 +#define FTS5_TOKENIZE_AUX 0x0008 + +/* Flags that may be passed by the tokenizer implementation back to FTS5 +** as the third argument to the supplied xToken callback. */ +#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */ + +/* +** END OF CUSTOM TOKENIZERS +*************************************************************************/ + +/************************************************************************* +** FTS5 EXTENSION REGISTRATION API +*/ +typedef struct fts5_api fts5_api; +struct fts5_api { + int iVersion; /* Currently always set to 2 */ + + /* Create a new tokenizer */ + int (*xCreateTokenizer)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_tokenizer *pTokenizer, + void (*xDestroy)(void*) + ); + + /* Find an existing tokenizer */ + int (*xFindTokenizer)( + fts5_api *pApi, + const char *zName, + void **ppContext, + fts5_tokenizer *pTokenizer + ); + + /* Create a new auxiliary function */ + int (*xCreateFunction)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_extension_function xFunction, + void (*xDestroy)(void*) + ); +}; + +/* +** END OF REGISTRATION API +*************************************************************************/ + +#ifdef __cplusplus +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _FTS5_H */ + +/******** End of fts5.h *********/ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..8b96434 --- /dev/null +++ b/main.cpp @@ -0,0 +1,127 @@ +#include +#include +#include "sqlite3.h" + +const char *DB_FILE_NAME = "example.sqlite"; + +sqlite3 *db = nullptr; +sqlite3_stmt *ins_log_stmt = nullptr; + +int create_tables() { + char *err_msg = nullptr; + int rc = sqlite3_exec( + db, + "CREATE TABLE IF NOT EXISTS logs("\ + "id INTEGER PRIMARY KEY AUTOINCREMENT,"\ + "data TEXT,"\ + "datetime TIMESTAMP DEFAULT CURRENT_TIMESTAMP"\ + ")", + NULL, + 0, + &err_msg + ); + if (rc) { + std::cout << "Error: " << err_msg << std::endl; + sqlite3_free(err_msg); + } + return rc; +} + +int prepare_statements() { + std::string sql = "INSERT INTO logs (data) VALUES (?);"; + return sqlite3_prepare_v2( + db, + sql.c_str(), + sql.length(), + &ins_log_stmt, + nullptr + ); +} + +static int logs_callback(void *data, int argc, char **argv, char **azColName){ + if (argc == 3) { + std::cout << argv[0] << ". (" << argv[2] << ") " << argv[1] << std::endl; + } else { + std::cout << "Error: Expected 3 columns, got " << argc << std::endl; + } + + return 0; +} + +int list_logs() { + char *err_msg = nullptr; + std::string sql = "SELECT id, data, datetime FROM logs"; + int rc = sqlite3_exec(db, sql.c_str(), logs_callback, NULL, &err_msg); + if (rc != SQLITE_OK) { + std::cout << "Error: " << err_msg << std::endl; + sqlite3_free(err_msg); + } + return rc; +} + +int insert_log(std::string data) { + int rc = sqlite3_bind_text( + ins_log_stmt, + 1, + data.c_str(), + data.length(), + SQLITE_STATIC + ); + if (rc) { + return rc; + } + + rc = sqlite3_step(ins_log_stmt); + if (rc != SQLITE_DONE) { + return rc; + } + + rc = sqlite3_reset(ins_log_stmt); + if (rc) { + return rc; + } + + return rc; +} + +int main() { + int rc = sqlite3_open(DB_FILE_NAME, &db); + if (rc) { + std::cout << "Error code: " << rc << std::endl; + return rc; + } + + rc = create_tables(); + if (rc) { + std::cout << "Error code: " << rc << std::endl; + return rc; + } + + rc = prepare_statements(); + if (rc) { + std::cout << "Error code: " << rc << std::endl; + return rc; + } + + rc = list_logs(); + if (rc) { + std::cout << "Error code: " << rc << std::endl; + return rc; + } + + rc = insert_log("wolf (test log)"); + if (rc) { + std::cout << "Error code123: " << rc << std::endl; + return rc; + } + + rc = insert_log("lion (test log2)"); + if (rc) { + std::cout << "Error code: " << rc << std::endl; + return rc; + } + + sqlite3_close(db); + + return 0; +} diff --git a/sqlite3.dll b/sqlite3.dll new file mode 100644 index 0000000000000000000000000000000000000000..a5ec8a41498a90e0a9e8333ffdf6e4549ce9b188 GIT binary patch literal 1071715 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

u7?Sq)>kTKWj(FHAbdTVWw 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∈@Z)S!21Rz(}h!tkHm{~EGt9z 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