From 8ef5e3c50a34b84d6097e994e5d21ff99f081ece Mon Sep 17 00:00:00 2001 From: Eduardo DAVILA Date: Wed, 5 Jun 2013 16:24:21 +0200 Subject: [PATCH] 2018 BUG Take out the SQLite(dll lib h) from source and put it in creaThirdPartyLibrary mechanism --- win32/CMakeLists.txt | 30 - win32/sqlite3.dll | Bin 409600 -> 0 bytes win32/sqlite3.h | 5734 -- win32/sqlite3.lib | Bin 41644 -> 0 bytes win64/CMakeLists.txt | 30 - win64/sqlite/CMakeLists.txt | 37 - win64/sqlite/Readme.txt | 18 - win64/sqlite/shell.c | 2635 - win64/sqlite/sqlite3.c | 112444 --------------------------------- win64/sqlite/sqlite3.def | 183 - win64/sqlite/sqlite3.h | 5734 -- win64/sqlite/sqlite3ext.h | 378 - win64/sqlite3.dll | Bin 875520 -> 0 bytes win64/sqlite3.h | 5734 -- win64/sqlite3.lib | Bin 40776 -> 0 bytes 15 files changed, 132957 deletions(-) delete mode 100644 win32/CMakeLists.txt delete mode 100644 win32/sqlite3.dll delete mode 100644 win32/sqlite3.h delete mode 100644 win32/sqlite3.lib delete mode 100644 win64/CMakeLists.txt delete mode 100644 win64/sqlite/CMakeLists.txt delete mode 100644 win64/sqlite/Readme.txt delete mode 100644 win64/sqlite/shell.c delete mode 100644 win64/sqlite/sqlite3.c delete mode 100644 win64/sqlite/sqlite3.def delete mode 100644 win64/sqlite/sqlite3.h delete mode 100644 win64/sqlite/sqlite3ext.h delete mode 100644 win64/sqlite3.dll delete mode 100644 win64/sqlite3.h delete mode 100644 win64/sqlite3.lib diff --git a/win32/CMakeLists.txt b/win32/CMakeLists.txt deleted file mode 100644 index 0903896..0000000 --- a/win32/CMakeLists.txt +++ /dev/null @@ -1,30 +0,0 @@ -# --------------------------------------------------------------------- -# -# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image -# pour la Santé) -# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton -# Previous Authors : Laurent Guigues, Jean-Pierre Roux -# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil -# -# This software is governed by the CeCILL-B license under French law and -# abiding by the rules of distribution of free software. You can use, -# modify and/ or redistribute the software under the terms of the CeCILL-B -# license as circulated by CEA, CNRS and INRIA at the following URL -# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html -# or in the file LICENSE.txt. -# -# As a counterpart to the access to the source code and rights to copy, -# modify and redistribute granted by the license, users are provided only -# with a limited warranty and the software's author, the holder of the -# economic rights, and the successive licensors have only limited -# liability. -# -# The fact that you are presently reading this means that you have had -# knowledge of the CeCILL-B license and that you accept its terms. -# ------------------------------------------------------------------------ - -IF (WIN32) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Debug/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Release/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/RelWithDebInfo/sqlite3.dll COPYONLY) -ENDIF(WIN32) \ No newline at end of file diff --git a/win32/sqlite3.dll b/win32/sqlite3.dll deleted file mode 100644 index 7b07c55bdac316471e468a1631717f128f8c84f0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 409600 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

&}@}O{XA2C?lxLE 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

wxSX){K$0#>PwoBzHVLo&-NZ-M$8*-5fC2 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 /* Needed for the definition of va_list */ - -/* -** Make sure we can call this stuff from C++. -*/ -#ifdef __cplusplus -extern "C" { -#endif - - -/* -** Add the ability to override 'extern' -*/ -#ifndef SQLITE_EXTERN -# define SQLITE_EXTERN extern -#endif - -#ifndef SQLITE_API -# define SQLITE_API -#endif - - -/* -** These no-op macros are used in front of interfaces to mark those -** interfaces as either deprecated or experimental. New applications -** should not use deprecated interfaces - they are support for backwards -** compatibility only. Application writers should be aware that -** experimental interfaces are subject to change in point releases. -** -** These macros used to resolve to various kinds of compiler magic that -** would generate warning messages when they were used. But that -** compiler magic ended up generating such a flurry of bug reports -** that we have taken it all out and gone back to using simple -** noop macros. -*/ -#define SQLITE_DEPRECATED -#define SQLITE_EXPERIMENTAL - -/* -** Ensure these symbols were not defined by some previous header file. -*/ -#ifdef SQLITE_VERSION -# undef SQLITE_VERSION -#endif -#ifdef SQLITE_VERSION_NUMBER -# undef SQLITE_VERSION_NUMBER -#endif - -/* -** CAPI3REF: Compile-Time Library Version Numbers -** -** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header -** evaluates to a string literal that is the SQLite version in the -** format "X.Y.Z" where X is the major version number (always 3 for -** SQLite3) and Y is the minor version number and Z is the release number.)^ -** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer -** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same -** numbers used in [SQLITE_VERSION].)^ -** The SQLITE_VERSION_NUMBER for any given release of SQLite will also -** be larger than the release from which it is derived. Either Y will -** be held constant and Z will be incremented or else Y will be incremented -** and Z will be reset to zero. -** -** Since version 3.6.18, SQLite source code has been stored in the -** Fossil configuration management -** system. ^The SQLITE_SOURCE_ID macro evalutes to -** a string which identifies a particular check-in of SQLite -** within its configuration management system. ^The SQLITE_SOURCE_ID -** string contains the date and time of the check-in (UTC) and an SHA1 -** hash of the entire source tree. -** -** See also: [sqlite3_libversion()], -** [sqlite3_libversion_number()], [sqlite3_sourceid()], -** [sqlite_version()] and [sqlite_source_id()]. -*/ -#define SQLITE_VERSION "3.6.23.1" -#define SQLITE_VERSION_NUMBER 3006023 -#define SQLITE_SOURCE_ID "2010-03-26 22:28:06 b078b588d617e07886ad156e9f54ade6d823568e" - -/* -** CAPI3REF: Run-Time Library Version Numbers -** KEYWORDS: sqlite3_version, sqlite3_sourceid -** -** These interfaces provide the same information as the [SQLITE_VERSION], -** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros -** but are associated with the library instead of the header file. ^(Cautious -** programmers might include assert() statements in their application to -** verify that values returned by these interfaces match the macros in -** the header, and thus insure that the application is -** compiled with matching library and header files. -** -** 

-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==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. -** -** 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); - -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS -/* -** 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 interating -** 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 specifing 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]. -*/ -SQLITE_API int sqlite3_compileoption_used(const char *zOptName); -SQLITE_API const char *sqlite3_compileoption_get(int N); -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ - -/* -** CAPI3REF: Test To See If The Library Is Threadsafe -** -** ^The sqlite3_threadsafe() function returns zero if and only if -** SQLite was compiled mutexing code omitted due to the -** [SQLITE_THREADSAFE] compile-time option being set to 0. -** -** SQLite can be compiled with or without mutexes. When -** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes -** are enabled and SQLite is threadsafe. When the -** [SQLITE_THREADSAFE] macro is 0, -** the mutexes are omitted. Without the mutexes, it is not safe -** to use SQLite concurrently from more than one thread. -** -** Enabling mutexes incurs a measurable performance penalty. -** So if speed is of utmost importance, it makes sense to disable -** the mutexes. But for maximum safety, mutexes should be enabled. -** ^The default behavior is for mutexes to be enabled. -** -** This interface can be used by an application to make sure that the -** version of SQLite that it is linking against was compiled with -** the desired setting of the [SQLITE_THREADSAFE] macro. -** -** This interface only reports on the compile-time mutex setting -** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with -** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but -** can be fully or partially disabled using a call to [sqlite3_config()] -** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], -** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the -** sqlite3_threadsafe() function shows only the compile-time setting of -** thread safety, not any run-time changes to that setting made by -** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() -** is unchanged by calls to sqlite3_config().)^ -** -** See the [threading mode] documentation for additional information. -*/ -SQLITE_API int sqlite3_threadsafe(void); - -/* -** CAPI3REF: Database Connection Handle -** KEYWORDS: {database connection} {database connections} -** -** Each open SQLite database is represented by a pointer to an instance of -** the opaque structure named "sqlite3". It is useful to think of an sqlite3 -** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and -** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] -** is its destructor. There are many other interfaces (such as -** [sqlite3_prepare_v2()], [sqlite3_create_function()], and -** [sqlite3_busy_timeout()] to name but three) that are methods on an -** sqlite3 object. -*/ -typedef struct sqlite3 sqlite3; - -/* -** CAPI3REF: 64-Bit Integer Types -** KEYWORDS: sqlite_int64 sqlite_uint64 -** -** Because there is no cross-platform way to specify 64-bit integer types -** SQLite includes typedefs for 64-bit signed and unsigned integers. -** -** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. -** The sqlite_int64 and sqlite_uint64 types are supported for backwards -** compatibility only. -** -** ^The sqlite3_int64 and sqlite_int64 types can store integer values -** between -9223372036854775808 and +9223372036854775807 inclusive. ^The -** sqlite3_uint64 and sqlite_uint64 types can store integer values -** between 0 and +18446744073709551615 inclusive. -*/ -#ifdef SQLITE_INT64_TYPE - typedef SQLITE_INT64_TYPE sqlite_int64; - typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; -#elif defined(_MSC_VER) || defined(__BORLANDC__) - typedef __int64 sqlite_int64; - typedef unsigned __int64 sqlite_uint64; -#else - typedef long long int sqlite_int64; - typedef unsigned long long int sqlite_uint64; -#endif -typedef sqlite_int64 sqlite3_int64; -typedef sqlite_uint64 sqlite3_uint64; - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite3_int64 -#endif - -/* -** CAPI3REF: Closing A Database Connection -** -** ^The sqlite3_close() routine is the destructor for the [sqlite3] object. -** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is -** successfullly destroyed and all associated resources are deallocated. -** -** Applications must [sqlite3_finalize | finalize] all [prepared statements] -** and [sqlite3_blob_close | close] all [BLOB handles] associated with -** the [sqlite3] object prior to attempting to close the object. ^If -** sqlite3_close() is called on a [database connection] that still has -** outstanding [prepared statements] or [BLOB handles], then it returns -** SQLITE_BUSY. -** -** ^If [sqlite3_close()] is invoked while a transaction is open, -** the transaction is automatically rolled back. -** -** The C parameter to [sqlite3_close(C)] must be either a NULL -** pointer or an [sqlite3] object pointer obtained -** from [sqlite3_open()], [sqlite3_open16()], or -** [sqlite3_open_v2()], and not previously closed. -** ^Calling sqlite3_close() with a NULL pointer argument is a -** harmless no-op. -*/ -SQLITE_API int sqlite3_close(sqlite3 *); - -/* -** The type for a callback function. -** This is legacy and deprecated. It is included for historical -** compatibility and is not documented. -*/ -typedef int (*sqlite3_callback)(void*,int,char**, char**); - -/* -** CAPI3REF: One-Step Query Execution Interface -** -** 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 -** to sqlite3_exec() is relayed through to the 1st argument of each -** callback invocation. ^If the callback pointer to sqlite3_exec() -** is NULL, then no callback is ever invoked and result rows are -** ignored. -** -** ^If an error occurs while evaluating the SQL statements passed into -** sqlite3_exec(), then execution of the current statement stops and -** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() -** is not NULL then any error message is written into memory obtained -** from [sqlite3_malloc()] and passed back through the 5th parameter. -** To avoid memory leaks, the application should invoke [sqlite3_free()] -** on error message strings returned through the 5th parameter of -** of sqlite3_exec() after the error message string is no longer needed. -** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors -** occur, then sqlite3_exec() sets the pointer in its 5th parameter to -** NULL before returning. -** -** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() -** routine returns SQLITE_ABORT without invoking the callback again and -** without running any subsequent SQL statements. -** -** ^The 2nd argument to the sqlite3_exec() callback function is the -** number of columns in the result. ^The 3rd argument to the sqlite3_exec() -** callback is an array of pointers to strings obtained as if from -** [sqlite3_column_text()], one for each column. ^If an element of a -** result row is NULL then the corresponding string pointer for the -** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the -** sqlite3_exec() callback is an array of pointers to strings where each -** entry represents the name of corresponding result column as obtained -** from [sqlite3_column_name()]. -** -** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer -** to an empty string, or a pointer that contains only whitespace and/or -** SQL comments, then no SQL statements are evaluated and the database -** is not changed. -** -** Restrictions: -** -**
    -**
  • The application must insure that the 1st parameter to sqlite3_exec() -** is a valid and open [database connection]. -**
  • The application must not close [database connection] specified by -** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. -**
  • The application must not modify the SQL statement text passed into -** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. -**
-*/ -SQLITE_API int sqlite3_exec( - sqlite3*, /* An open database */ - const char *sql, /* SQL to be evaluated */ - int (*callback)(void*,int,char**,char**), /* Callback function */ - void *, /* 1st argument to callback */ - char **errmsg /* Error msg written here */ -); - -/* -** CAPI3REF: Result Codes -** KEYWORDS: SQLITE_OK {error code} {error codes} -** KEYWORDS: {result code} {result codes} -** -** Many SQLite functions return an integer result code from the set shown -** here in order to indicates success or failure. -** -** New error codes may be added in future versions of SQLite. -** -** See also: [SQLITE_IOERR_READ | extended result codes] -*/ -#define SQLITE_OK 0 /* Successful result */ -/* beginning-of-error-codes */ -#define SQLITE_ERROR 1 /* SQL error or missing database */ -#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ -#define SQLITE_PERM 3 /* Access permission denied */ -#define SQLITE_ABORT 4 /* Callback routine requested an abort */ -#define SQLITE_BUSY 5 /* The database file is locked */ -#define SQLITE_LOCKED 6 /* A table in the database is locked */ -#define SQLITE_NOMEM 7 /* A malloc() failed */ -#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ -#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ -#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ -#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ -#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ -#define SQLITE_FULL 13 /* Insertion failed because database is full */ -#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ -#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ -#define SQLITE_EMPTY 16 /* Database is empty */ -#define SQLITE_SCHEMA 17 /* The database schema changed */ -#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ -#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ -#define SQLITE_MISMATCH 20 /* Data type mismatch */ -#define SQLITE_MISUSE 21 /* Library used incorrectly */ -#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ -#define SQLITE_AUTH 23 /* Authorization denied */ -#define SQLITE_FORMAT 24 /* Auxiliary database format error */ -#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ -#define SQLITE_NOTADB 26 /* File opened that is not a database file */ -#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ -#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ -/* end-of-error-codes */ - -/* -** CAPI3REF: Extended Result Codes -** KEYWORDS: {extended error code} {extended error codes} -** KEYWORDS: {extended result code} {extended result codes} -** -** In its default configuration, SQLite API routines return one of 26 integer -** [SQLITE_OK | result codes]. However, experience has shown that many of -** these result codes are too coarse-grained. They do not provide as -** much information about problems as programmers might like. In an effort to -** address this, newer versions of SQLite (version 3.3.8 and later) include -** support for additional result codes that provide more detailed information -** about errors. The extended result codes are enabled or disabled -** on a per database connection basis using the -** [sqlite3_extended_result_codes()] API. -** -** Some of the available extended result codes are listed here. -** One may expect the number of extended result codes will be expand -** over time. Software that uses extended result codes should expect -** to see new result codes in future releases of SQLite. -** -** The SQLITE_OK result code will never be extended. It will always -** be exactly zero. -*/ -#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) -#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) -#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) -#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) -#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) -#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) -#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) -#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) -#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) -#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) -#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) -#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) -#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) -#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) -#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) -#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) -#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) -#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8) ) - -/* -** CAPI3REF: Flags For File Open Operations -** -** These bit values are intended for use in the -** 3rd parameter to the [sqlite3_open_v2()] interface and -** in the 4th parameter to the xOpen method of the -** [sqlite3_vfs] object. -*/ -#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ -#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ -#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ -#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ -#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ -#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ -#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ -#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ -#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ -#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ -#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ - -/* -** CAPI3REF: Device Characteristics -** -** The xDeviceCapabilities method of the [sqlite3_io_methods] -** object returns an integer which is a vector of the these -** bit values expressing I/O characteristics of the mass storage -** device that holds the file that the [sqlite3_io_methods] -** refers to. -** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -*/ -#define SQLITE_IOCAP_ATOMIC 0x00000001 -#define SQLITE_IOCAP_ATOMIC512 0x00000002 -#define SQLITE_IOCAP_ATOMIC1K 0x00000004 -#define SQLITE_IOCAP_ATOMIC2K 0x00000008 -#define SQLITE_IOCAP_ATOMIC4K 0x00000010 -#define SQLITE_IOCAP_ATOMIC8K 0x00000020 -#define SQLITE_IOCAP_ATOMIC16K 0x00000040 -#define SQLITE_IOCAP_ATOMIC32K 0x00000080 -#define SQLITE_IOCAP_ATOMIC64K 0x00000100 -#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 -#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 - -/* -** CAPI3REF: File Locking Levels -** -** 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(). -*/ -#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 xOpen method sets the sqlite3_file.pMethods element -** to a non-NULL pointer, then the sqlite3_io_methods.xClose method -** may be invoked even if the xOpen reported that it failed. The -** only way to prevent a call to xClose following a failed xOpen -** is for the xOpen to set the sqlite3_file.pMethods element to NULL. -** -** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or -** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). -** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] -** flag may be ORed in to indicate that only the data of the file -** and not its inode needs to be synced. -** -** The integer values to xLock() and xUnlock() are one of -**
    -**
  • [SQLITE_LOCK_NONE], -**
  • [SQLITE_LOCK_SHARED], -**
  • [SQLITE_LOCK_RESERVED], -**
  • [SQLITE_LOCK_PENDING], or -**
  • [SQLITE_LOCK_EXCLUSIVE]. -**
-** xLock() increases the lock. xUnlock() decreases the lock. -** The xCheckReservedLock() method checks whether any database connection, -** either in this process or in some other process, is holding a RESERVED, -** PENDING, or EXCLUSIVE lock on the file. It returns true -** if such a lock exists and false otherwise. -** -** The xFileControl() method is a generic interface that allows custom -** VFS implementations to directly control an open file using the -** [sqlite3_file_control()] interface. The second "op" argument is an -** integer opcode. The third argument is a generic pointer intended to -** point to a structure that may contain arguments or space in which to -** write return values. Potential uses for xFileControl() might be -** functions to enable blocking locks with timeouts, to change the -** locking strategy (for example to use dot-file locks), to inquire -** about the status of a lock, or to break stale locks. The SQLite -** core reserves all opcodes less than 100 for its own use. -** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. -** Applications that define a custom xFileControl method should use opcodes -** greater than 100 to avoid conflicts. -** -** The xSectorSize() method returns the sector size of the -** device that underlies the file. The sector size is the -** minimum write that can be performed without disturbing -** other bytes in the file. The xDeviceCharacteristics() -** method returns a bit vector describing behaviors of the -** underlying device: -** -**
    -**
  • [SQLITE_IOCAP_ATOMIC] -**
  • [SQLITE_IOCAP_ATOMIC512] -**
  • [SQLITE_IOCAP_ATOMIC1K] -**
  • [SQLITE_IOCAP_ATOMIC2K] -**
  • [SQLITE_IOCAP_ATOMIC4K] -**
  • [SQLITE_IOCAP_ATOMIC8K] -**
  • [SQLITE_IOCAP_ATOMIC16K] -**
  • [SQLITE_IOCAP_ATOMIC32K] -**
  • [SQLITE_IOCAP_ATOMIC64K] -**
  • [SQLITE_IOCAP_SAFE_APPEND] -**
  • [SQLITE_IOCAP_SEQUENTIAL] -**
-** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -** -** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill -** in the unread portions of the buffer with zeros. A VFS that -** fails to zero-fill short reads might seem to work. However, -** failure to zero-fill short reads will eventually lead to -** database corruption. -*/ -typedef struct sqlite3_io_methods sqlite3_io_methods; -struct sqlite3_io_methods { - int iVersion; - int (*xClose)(sqlite3_file*); - int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); - int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); - int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); - int (*xSync)(sqlite3_file*, int flags); - int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); - int (*xLock)(sqlite3_file*, int); - int (*xUnlock)(sqlite3_file*, int); - int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); - int (*xFileControl)(sqlite3_file*, int op, void *pArg); - int (*xSectorSize)(sqlite3_file*); - int (*xDeviceCharacteristics)(sqlite3_file*); - /* Additional methods may be added in future releases */ -}; - -/* -** CAPI3REF: Standard File Control Opcodes -** -** These integer constants are opcodes for the xFileControl method -** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] -** interface. -** -** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This -** opcode causes the xFileControl method to write the current state of -** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], -** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) -** into an integer that the pArg argument points to. This capability -** is used during testing and only needs to be supported when SQLITE_TEST -** is defined. -*/ -#define SQLITE_FCNTL_LOCKSTATE 1 -#define SQLITE_GET_LOCKPROXYFILE 2 -#define SQLITE_SET_LOCKPROXYFILE 3 -#define SQLITE_LAST_ERRNO 4 - -/* -** CAPI3REF: Mutex Handle -** -** The mutex module within SQLite defines [sqlite3_mutex] to be an -** abstract type for a mutex object. The SQLite core never looks -** at the internal representation of an [sqlite3_mutex]. It only -** deals with pointers to the [sqlite3_mutex] object. -** -** Mutexes are created using [sqlite3_mutex_alloc()]. -*/ -typedef struct sqlite3_mutex sqlite3_mutex; - -/* -** CAPI3REF: OS Interface Object -** -** An instance of the sqlite3_vfs object defines the interface between -** the SQLite core and the underlying operating system. The "vfs" -** in the name of the object stands for "virtual file system". -** -** The value of the iVersion field is initially 1 but may be larger in -** future versions of SQLite. Additional fields may be appended to this -** object when the iVersion value is increased. Note that the structure -** of the sqlite3_vfs object changes in the transaction between -** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not -** modified. -** -** The szOsFile field is the size of the subclassed [sqlite3_file] -** structure used by this VFS. mxPathname is the maximum length of -** a pathname in this VFS. -** -** Registered sqlite3_vfs objects are kept on a linked list formed by -** the pNext pointer. The [sqlite3_vfs_register()] -** and [sqlite3_vfs_unregister()] interfaces manage this list -** in a thread-safe way. The [sqlite3_vfs_find()] interface -** searches the list. Neither the application code nor the VFS -** implementation should use the pNext pointer. -** -** The pNext field is the only field in the sqlite3_vfs -** structure that SQLite will ever modify. SQLite will only access -** or modify this field while holding a particular static mutex. -** The application should never modify anything within the sqlite3_vfs -** object once the object has been registered. -** -** The zName field holds the name of the VFS module. The name must -** be unique across all VFS modules. -** -** SQLite will guarantee that the zFilename parameter to xOpen -** is either a NULL pointer or string obtained -** from xFullPathname(). SQLite further guarantees that -** the string will be valid and unchanged until xClose() is -** called. Because of the previous sentence, -** the [sqlite3_file] can safely store a pointer to the -** filename if it needs to remember the filename for some reason. -** If the zFilename parameter is xOpen is a NULL pointer then xOpen -** must invent its own temporary name for the file. Whenever the -** xFilename parameter is NULL it will also be the case that the -** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. -** -** The flags argument to xOpen() includes all bits set in -** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] -** or [sqlite3_open16()] is used, then flags includes at least -** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. -** If xOpen() opens a file read-only then it sets *pOutFlags to -** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. -** -** SQLite will also add one of the following flags to the xOpen() -** call, depending on the object being opened: -** -**
    -**
  • [SQLITE_OPEN_MAIN_DB] -**
  • [SQLITE_OPEN_MAIN_JOURNAL] -**
  • [SQLITE_OPEN_TEMP_DB] -**
  • [SQLITE_OPEN_TEMP_JOURNAL] -**
  • [SQLITE_OPEN_TRANSIENT_DB] -**
  • [SQLITE_OPEN_SUBJOURNAL] -**
  • [SQLITE_OPEN_MASTER_JOURNAL] -**
-** -** 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: -** -**
    -**
  • [SQLITE_OPEN_DELETEONCLOSE] -**
  • [SQLITE_OPEN_EXCLUSIVE] -**
-** -** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be -** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE] -** will be set for TEMP databases, journals and for subjournals. -** -** The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction -** with the [SQLITE_OPEN_CREATE] flag, which are both directly -** analogous to the O_EXCL and O_CREAT flags of the POSIX open() -** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the -** SQLITE_OPEN_CREATE, is used to indicate that file should always -** be created, and that it is an error if it already exists. -** It is 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. -** -** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] -** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to -** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] -** to test whether a file is at least readable. The file can be a -** directory. -** -** SQLite will always allocate at least mxPathname+1 bytes for the -** output buffer xFullPathname. The exact size of the output buffer -** is also passed as a parameter to both methods. If the output buffer -** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is -** handled as a fatal error by SQLite, vfs implementations should endeavor -** to prevent this by setting mxPathname to a sufficiently large value. -** -** The xRandomness(), xSleep(), and xCurrentTime() interfaces -** are not strictly a part of the filesystem, but they are -** included in the VFS structure for completeness. -** The xRandomness() function attempts to return nBytes bytes -** of good-quality randomness into zOut. The return value is -** the actual number of bytes of randomness obtained. -** The xSleep() method causes the calling thread to sleep for at -** least the number of microseconds given. The xCurrentTime() -** method returns a Julian Day Number for the current date and time. -** -*/ -typedef struct sqlite3_vfs sqlite3_vfs; -struct sqlite3_vfs { - int iVersion; /* Structure version number */ - int szOsFile; /* Size of subclassed sqlite3_file */ - int mxPathname; /* Maximum file pathname length */ - sqlite3_vfs *pNext; /* Next registered VFS */ - const char *zName; /* Name of this virtual file system */ - void *pAppData; /* Pointer to application-specific data */ - int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, - int flags, int *pOutFlags); - int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); - int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); - int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); - void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); - void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); - void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); - void (*xDlClose)(sqlite3_vfs*, void*); - int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); - int (*xSleep)(sqlite3_vfs*, int microseconds); - int (*xCurrentTime)(sqlite3_vfs*, double*); - int (*xGetLastError)(sqlite3_vfs*, int, char *); - /* New fields may be appended in figure versions. The iVersion - ** value will increment whenever this happens. */ -}; - -/* -** CAPI3REF: Flags for the xAccess VFS method -** -** 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 file is both readable and writable. -** With SQLITE_ACCESS_READ, the xAccess method -** checks whether the file is readable. -*/ -#define SQLITE_ACCESS_EXISTS 0 -#define SQLITE_ACCESS_READWRITE 1 -#define SQLITE_ACCESS_READ 2 - -/* -** CAPI3REF: Initialize The SQLite Library -** -** ^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 insure that no other SQLite interfaces are invoked by other -** threads while sqlite3_config() is running. Furthermore, sqlite3_config() -** may only be invoked prior to library initialization using -** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. -** ^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 -** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines -** what property of SQLite is to be configured. Subsequent arguments -** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option] -** in the first argument. -** -** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. -** ^If the option is unknown or SQLite is unable to set the option -** then this routine returns a non-zero [error code]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_config(int, ...); - -/* -** CAPI3REF: Configure database connections -** EXPERIMENTAL -** -** The sqlite3_db_config() interface is used to make configuration -** changes to a [database connection]. The interface is similar to -** [sqlite3_config()] except that the changes apply to a single -** [database connection] (specified in the first argument). The -** sqlite3_db_config() interface should only be used immediately after -** the database connection is created using [sqlite3_open()], -** [sqlite3_open16()], or [sqlite3_open_v2()]. -** -** The second argument to sqlite3_db_config(D,V,...) is the -** configuration verb - an integer code that indicates what -** aspect of the [database connection] is being configured. -** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE]. -** New verbs are likely to be added in future releases of SQLite. -** Additional arguments depend on the verb. -** -** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if -** the call is considered successful. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...); - -/* -** CAPI3REF: Memory Allocation Routines -** EXPERIMENTAL -** -** An instance of this object defines the interface between SQLite -** and low-level memory allocation routines. -** -** This object is used in only one place in the SQLite interface. -** A pointer to an instance of this object is the argument to -** [sqlite3_config()] when the configuration option is -** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. -** By creating an instance of this object -** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) -** during configuration, an application can specify an alternative -** memory allocation subsystem for SQLite to use for all of its -** dynamic memory needs. -** -** Note that SQLite comes with several [built-in memory allocators] -** that are perfectly adequate for the overwhelming majority of applications -** and that this object is only useful to a tiny minority of applications -** with specialized memory allocation requirements. This object is -** also used during testing of SQLite in order to specify an alternative -** memory allocator that simulates memory out-of-memory conditions in -** order to verify that SQLite recovers gracefully from such -** conditions. -** -** The xMalloc and xFree methods must work like the -** malloc() and free() functions from the standard C library. -** The xRealloc method must work like realloc() from the standard C library -** with the exception that if the second argument to xRealloc is zero, -** xRealloc must be a no-op - it must not perform any allocation or -** deallocation. ^SQLite guarantees that the second argument to -** xRealloc is always a value returned by a prior call to xRoundup. -** And so in cases where xRoundup always returns a positive number, -** xRealloc can perform exactly as the standard library realloc() and -** still be in compliance with this specification. -** -** xSize should return the allocated size of a memory allocation -** previously obtained from xMalloc or xRealloc. The allocated size -** is always at least as big as the requested size but may be larger. -** -** The xRoundup method returns what would be the allocated size of -** a memory allocation given a particular requested size. Most memory -** allocators round up memory allocations at least to the next multiple -** of 8. Some allocators round up to a larger multiple or to a power of 2. -** 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 require 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_MASTER] 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 -** EXPERIMENTAL -** -** 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
-**
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
-**
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
-**
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
-**
^(This 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
-**
^(This 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_MEMSTATUS
-**
^This 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_memory_used()] -**
  • [sqlite3_memory_highwater()] -**
  • [sqlite3_soft_heap_limit()] -**
  • [sqlite3_status()] -**
)^ -** ^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
-**
^This option specifies a static memory buffer that SQLite can use for -** scratch memory. There are three arguments: A pointer an 8-byte -** aligned memory buffer from which the scrach allocations will be -** drawn, the size of each scratch allocation (sz), -** and the maximum number of scratch allocations (N). The sz -** argument must be a multiple of 16. The sz parameter should be a few bytes -** larger than the actual scratch space required due to internal overhead. -** The first argument must be a pointer to an 8-byte aligned buffer -** of at least sz*N bytes of memory. -** ^SQLite will use no more than one scratch buffer per thread. So -** N should be set to the expected maximum number of threads. ^SQLite will -** never require a scratch buffer that is more than 6 times the database -** page size. ^If SQLite needs needs additional scratch memory beyond -** what is provided by this configuration option, then -** [sqlite3_malloc()] will be used to obtain the memory needed.
-** -**
SQLITE_CONFIG_PAGECACHE
-**
^This option specifies a static memory buffer that SQLite can use for -** the database page cache with the default page cache implemenation. -** This configuration should not be used if an application-define page -** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option. -** There are three arguments to this option: A pointer to 8-byte aligned -** memory, the size of each page buffer (sz), and the number of pages (N). -** The sz argument should be the size of the largest database page -** (a power of two between 512 and 32768) plus a little extra for each -** page header. ^The page header size is 20 to 40 bytes depending on -** the host architecture. ^It is harmless, apart from the wasted memory, -** to make sz a little too large. The first -** argument should point to an allocation of at least sz*N bytes of memory. -** ^SQLite will use the memory provided by the first argument to satisfy its -** memory needs for the first N pages that it adds to cache. ^If additional -** page cache memory is needed beyond what is provided by this option, then -** SQLite goes to [sqlite3_malloc()] for the additional storage space. -** ^The implementation might use one or more of the N buffers to hold -** memory accounting information. The pointer in the first argument must -** be aligned to an 8-byte boundary or subsequent behavior of SQLite -** will be undefined.
-** -**
SQLITE_CONFIG_HEAP
-**
^This 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_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. -** There are three arguments: 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 and either [SQLITE_ENABLE_MEMSYS3] or -** [SQLITE_ENABLE_MEMSYS5] are defined, 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.
-** -**
SQLITE_CONFIG_MUTEX
-**
^(This 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
-**
^(This 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
-**
^(This option takes two arguments that determine the default -** memory allocation for the lookaside memory allocator 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.)^ ^(This option sets the -** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] -** verb to [sqlite3_db_config()] can be used to change the lookaside -** configuration on individual connections.)^
-** -**
SQLITE_CONFIG_PCACHE
-**
^(This option takes a single argument which is a pointer to -** an [sqlite3_pcache_methods] object. This object specifies the interface -** to a custom page cache implementation.)^ ^SQLite makes a copy of the -** object and uses it for page cache memory allocations.
-** -**
SQLITE_CONFIG_GETPCACHE
-**
^(This option takes a single argument which is a pointer to an -** [sqlite3_pcache_methods] object. SQLite copies of the current -** page cache implementation into that object.)^
-** -**
-*/ -#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 /* void*, int sz, int N */ -#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 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_GETPCACHE 15 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** 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
-**
^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 an 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. See also: [SQLITE_CONFIG_LOOKASIDE]
-** -**
-*/ -#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ - - -/* -** CAPI3REF: Enable Or Disable Extended Result Codes -** -** ^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 -** -** ^Each entry in an SQLite table 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. -** -** ^This routine returns the [rowid] of the most recent -** successful [INSERT] into the database from the [database connection] -** in the first argument. ^If no successful [INSERT]s -** have ever occurred on that database connection, zero is returned. -** -** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted -** row is returned by this routine as long as the trigger is running. -** But once the trigger terminates, the value returned by this routine -** reverts to the last value inserted before the trigger 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: Count The Number Of Rows Modified -** -** ^This function returns the number of database rows that were changed -** or inserted or deleted by the most recently completed SQL statement -** on the [database connection] specified by the first parameter. -** ^(Only changes that are directly specified by the [INSERT], [UPDATE], -** or [DELETE] statement are counted. Auxiliary changes caused by -** triggers or [foreign key actions] are not counted.)^ Use the -** [sqlite3_total_changes()] function to find the total number of changes -** including changes caused by triggers and foreign key actions. -** -** ^Changes to a view that are simulated by an [INSTEAD OF trigger] -** are not counted. Only real table changes are counted. -** -** ^(A "row change" is a change to a single row of a single table -** caused by an INSERT, DELETE, or UPDATE statement. Rows that -** are changed as side effects of [REPLACE] constraint resolution, -** rollback, ABORT processing, [DROP TABLE], or by any other -** mechanisms do not count as direct row changes.)^ -** -** A "trigger context" is a scope of execution that begins and -** ends with the script of a [CREATE TRIGGER | trigger]. -** Most SQL statements are -** evaluated outside of any trigger. This is the "top level" -** trigger context. If a trigger fires from the top level, a -** new trigger context is entered for the duration of that one -** trigger. Subtriggers create subcontexts for their duration. -** -** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does -** not create a new trigger context. -** -** ^This function returns the number of direct row changes in the -** most recent INSERT, UPDATE, or DELETE statement within the same -** trigger context. -** -** ^Thus, when called from the top level, this function returns the -** number of changes in the most recent INSERT, UPDATE, or DELETE -** that also occurred at the top level. ^(Within the body of a trigger, -** the sqlite3_changes() interface can be called to find the number of -** changes in the most recently completed INSERT, UPDATE, or DELETE -** statement within the body of the same trigger. -** However, the number returned does not include changes -** caused by subtriggers since those have their own context.)^ -** -** See also the [sqlite3_total_changes()] interface, the -** [count_changes pragma], and the [changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_changes(sqlite3*); - -/* -** CAPI3REF: Total Number Of Rows Modified -** -** ^This function returns the number of row changes caused by [INSERT], -** [UPDATE] or [DELETE] statements since the [database connection] was opened. -** ^(The count returned by sqlite3_total_changes() includes all changes -** from all [CREATE TRIGGER | trigger] contexts and changes made by -** [foreign key actions]. However, -** the count does not include changes used to implement [REPLACE] constraints, -** do rollbacks or ABORT processing, or [DROP TABLE] processing. The -** count does not include rows of views that fire an [INSTEAD OF trigger], -** though if the INSTEAD OF trigger makes changes of its own, those changes -** are counted.)^ -** ^The sqlite3_total_changes() function counts the changes as soon as -** the statement that makes them is completed (when the statement handle -** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). -** -** See also the [sqlite3_changes()] interface, the -** [count_changes pragma], and the [total_changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_total_changes(sqlite3*); - -/* -** CAPI3REF: Interrupt A Long-Running Query -** -** ^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 statements 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. -** -** If the database connection closes while [sqlite3_interrupt()] -** is running then bad things will likely happen. -*/ -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 -** -** ^This routine sets a callback function that might be invoked whenever -** an attempt is made to open a database table that another thread -** or process has locked. -** -** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] -** 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 for this locking event. ^If the -** busy callback returns 0, then no additional attempts are made to -** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. -** ^If the callback returns non-zero, then another attempt -** is made to open the database for reading 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] -** or [SQLITE_IOERR_BLOCKED] 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. -** -** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] -** when SQLite is in the middle of a large transaction where all the -** changes will not fit into the in-memory cache. SQLite will -** already hold a RESERVED lock on the database file, but it needs -** to promote this lock to EXCLUSIVE so that it can spill cache -** pages into the database file without harm to concurrent -** readers. ^If it is unable to promote the lock, then the in-memory -** cache will be left in an inconsistent state and so the error -** code is promoted from the relatively benign [SQLITE_BUSY] to -** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion -** forces an automatic rollback of the changes. See the -** -** CorruptionFollowingBusyError wiki page for a discussion of why -** this is important. -** -** ^(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()] -** will also set or clear the busy handler. -** -** The busy callback should not take any actions which modify the -** database connection that invoked the busy handler. 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 -** -** ^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] or [SQLITE_IOERR_BLOCKED]. -** -** ^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] any any given moment. If another busy handler -** was defined (using [sqlite3_busy_handler()]) prior to calling -** this routine, that other busy handler is cleared.)^ -*/ -SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); - -/* -** CAPI3REF: Convenience Routines For Running Queries -** -** 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 column (M==2) and three rows (N==3). Thus the -** result table has 8 entries. Suppose the result table is stored -** in an array names 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 should 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. -** -** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their -** results into memory obtained from [sqlite3_malloc()]. -** The strings returned by these two routines should be -** released by [sqlite3_free()]. ^Both routines return a -** NULL pointer if [sqlite3_malloc()] is unable to allocate enough -** memory to hold the resulting string. -** -** ^(In 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. -** -** These routines all implement some additional formatting -** options that are useful for constructing SQL statements. -** All of the usual printf() formatting options apply. In addition, there -** is are "%q", "%Q", and "%z" options. -** -** ^(The %q option works like %s in that it substitutes a null-terminated -** string from the argument list. But %q also doubles every '\'' character. -** %q is designed for use inside a string literal.)^ By doubling each '\'' -** character it escapes that character and allows it to be inserted into -** the string. -** -** For example, assume the string variable zText contains text as follows: -** -** 
-**  char *zText = "It's a happy day!";
-**
-** -** One can use this text in an SQL statement as follows: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** Because the %q format string is used, the '\'' character in zText -** is escaped and the SQL generated is as follows: -** -** 
-**  INSERT INTO table1 VALUES('It''s a happy day!')
-**
-** -** This is correct. Had we used %s instead of %q, the generated SQL -** would have looked like this: -** -** 
-**  INSERT INTO table1 VALUES('It's a happy day!');
-**
-** -** This second example is an SQL syntax error. As a general rule you should -** always use %q instead of %s when inserting text into a string literal. -** -** ^(The %Q option works like %q except it also adds single quotes around -** the outside of the total string. Additionally, if the parameter in the -** argument list is a NULL pointer, %Q substitutes the text "NULL" (without -** single quotes).)^ So, for example, one could say: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** The code above will render a correct SQL statement in the zSQL -** variable even if the zText variable is a NULL pointer. -** -** ^(The "%z" formatting option works like "%s" but with the -** addition that after the string has been read and copied into -** the result, [sqlite3_free()] is called on the input string.)^ -*/ -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*, ...); - -/* -** 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. -** -** ^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() interface attempts to resize a -** prior memory allocation to be at least N bytes, where N is the -** second parameter. The memory allocation to be resized is the first -** parameter.)^ ^ If the first parameter to sqlite3_realloc() -** is a NULL pointer then its behavior is identical to calling -** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). -** ^If the second parameter to sqlite3_realloc() is zero or -** negative then the behavior is exactly the same as calling -** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). -** ^sqlite3_realloc() returns a pointer to a memory allocation -** of at least N bytes in size or NULL if sufficient memory is unavailable. -** ^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() and the prior allocation is freed. -** ^If sqlite3_realloc() returns NULL, then the prior allocation -** is not freed. -** -** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() -** is always aligned to at least an 8 byte boundary. -** -** In SQLite version 3.5.0 and 3.5.1, it was possible to define -** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in -** implementation of these routines to be omitted. That capability -** is no longer provided. Only built-in memory allocators can be used. -** -** The Windows OS interface layer calls -** the system malloc() and free() directly when converting -** filenames between the UTF-8 encoding used by SQLite -** and whatever filename encoding is used by the particular Windows -** installation. Memory allocation errors are detected, but -** they are reported back as [SQLITE_CANTOPEN] or -** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. -** -** 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_realloc(void*, int); -SQLITE_API void sqlite3_free(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 build-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 first time this routine is invoked (either internally or by -** the application) the PRNG is seeded using randomness obtained -** from the xRandomness method of the default [sqlite3_vfs] object. -** ^On all subsequent invocations, 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 -** -** ^This routine registers a 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_prepare16()] and [sqlite3_prepare16_v2()]. ^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 zero-terminated strings that contain additional -** details about the action to be authorized. -** -** ^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. -** ^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. -*/ -#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 */ - -/* -** CAPI3REF: Tracing And Profiling Functions -** EXPERIMENTAL -** -** 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 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. -*/ -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, - void(*xProfile)(void*,const char*,sqlite3_uint64), void*); - -/* -** CAPI3REF: Query Progress Callbacks -** -** ^This routine configures a callback function - the -** progress callback - that is invoked periodically during long -** running calls to [sqlite3_exec()], [sqlite3_step()] and -** [sqlite3_get_table()]. An example use for this -** interface is to keep a GUI updated during a large query. -** -** ^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 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 -** -** ^These routines open an SQLite database file whose name is given 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 for the database will be UTF-8 if -** sqlite3_open() or sqlite3_open_v2() is called and -** UTF-16 in the native byte order if sqlite3_open16() is used. -** -** 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() can take one of -** the following three values, optionally combined with the -** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], -** and/or [SQLITE_OPEN_PRIVATECACHE] flags:)^ -** -**
-** ^(
[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 creates it if -** it does not already exist. This is the behavior that is always used for -** sqlite3_open() and sqlite3_open16().
)^ -**
-** -** If the 3rd parameter to sqlite3_open_v2() is not one of the -** combinations shown above or one of the combinations shown above combined -** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], -** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags, -** then the behavior is undefined. -** -** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection -** opens in the multi-thread [threading mode] as long as the single-thread -** mode has not been set at compile-time or start-time. ^If the -** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens -** in the serialized [threading mode] unless single-thread was -** previously selected at compile-time or start-time. -** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be -** eligible to use [shared cache mode], regardless of whether or not shared -** cache is enabled using [sqlite3_enable_shared_cache()]. ^The -** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not -** participate in [shared cache mode] even if it is enabled. -** -** ^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. -** -** ^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. -** -** 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(). -*/ -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: Error Codes And Messages -** -** ^The sqlite3_errcode() interface returns the numeric [result code] or -** [extended result code] for the most recent failed sqlite3_* API call -** associated with a [database connection]. If a prior API call failed -** but the most recent API call succeeded, the return value from -** sqlite3_errcode() is undefined. ^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 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.)^ -** -** 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*); - -/* -** CAPI3REF: SQL Statement Object -** KEYWORDS: {prepared statement} {prepared statements} -** -** An instance of this object represents a single SQL statement. -** This object is variously known as a "prepared statement" or a -** "compiled SQL statement" or simply as a "statement". -** -** The life of a statement object goes something like this: -** -**
    -**
  1. Create the object using [sqlite3_prepare_v2()] or a related -** function. -**
  2. Bind values to [host parameters] using the sqlite3_bind_*() -** interfaces. -**
  3. Run the SQL by calling [sqlite3_step()] one or more times. -**
  4. Reset the statement using [sqlite3_reset()] then go back -** to step 2. Do this zero or more times. -**
  5. Destroy the object using [sqlite3_finalize()]. -**
-** -** Refer to documentation on individual methods above for additional -** information. -*/ -typedef struct sqlite3_stmt sqlite3_stmt; - -/* -** CAPI3REF: Run-time Limits -** -** ^(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. The function returns the old limit.)^ -** -** ^If the new limit is a negative number, the limit is unchanged. -** ^(For the limit category of SQLITE_LIMIT_XYZ there is a -** [limits | hard upper bound] -** set by a compile-time C preprocessor macro named -** [limits | SQLITE_MAX_XYZ]. -** (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. -** -** 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
-**
The maximum size of any string or BLOB or table row.
)^ -** -** ^(
SQLITE_LIMIT_SQL_LENGTH
-**
The maximum length of an SQL statement, in bytes.
)^ -** -** ^(
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
-**
The maximum depth of the parse tree on any expression.
)^ -** -** ^(
SQLITE_LIMIT_COMPOUND_SELECT
-**
The maximum number of terms in a compound SELECT statement.
)^ -** -** ^(
SQLITE_LIMIT_VDBE_OP
-**
The maximum number of instructions in a virtual machine program -** used to implement an SQL statement.
)^ -** -** ^(
SQLITE_LIMIT_FUNCTION_ARG
-**
The maximum number of arguments on a function.
)^ -** -** ^(
SQLITE_LIMIT_ATTACHED
-**
The maximum number of [ATTACH | attached databases].)^
-** -** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
-**
The maximum length of the pattern argument to the [LIKE] or -** [GLOB] operators.
)^ -** -** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
-**
The maximum number of variables in an SQL statement that can -** be bound.
)^ -** -** ^(
SQLITE_LIMIT_TRIGGER_DEPTH
-**
The maximum depth of recursion for triggers.
)^ -**
-*/ -#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 - -/* -** CAPI3REF: Compiling An SQL Statement -** KEYWORDS: {SQL statement compiler} -** -** To execute an SQL query, it must first be compiled into a byte-code -** program using one of these routines. -** -** 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() and sqlite3_prepare_v2() -** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() -** use UTF-16. -** -** ^If the nByte argument is less than zero, then zSql is read up to the -** first zero terminator. ^If nByte is non-negative, then it is the maximum -** number of bytes read from zSql. ^When nByte is non-negative, the -** zSql string ends at either the first '\000' or '\u0000' character or -** the nByte-th byte, whichever comes first. If the caller knows -** that the supplied string is nul-terminated, then there is a small -** performance advantage to be gained by passing an nByte parameter that -** is equal to the number of bytes in the input string including -** the nul-terminator bytes. -** -** ^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() and sqlite3_prepare16_v2() interfaces are -** recommended for all new programs. The two older interfaces are retained -** for backwards compatibility, but their use is discouraged. -** ^In the "v2" 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. ^If the schema has changed in -** a way that makes the statement no longer valid, [sqlite3_step()] will still -** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is -** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the -** error go away. Note: use [sqlite3_errmsg()] to find the text -** of the parsing error that results in an [SQLITE_SCHEMA] return. -**
    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 value of a [parameter | host parameter] in the WHERE clause might -** change the query plan for a statement, then the statement may 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 the [parameter]. -**
    4. -**
-*/ -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_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 */ -); - -/* -** CAPI3REF: Retrieving Statement SQL -** -** ^This interface can be used to retrieve a saved copy of the original -** SQL text used to create a [prepared statement] if that statement was -** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. -*/ -SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); - -/* -** 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 terms "protected" and "unprotected" refer to whether or not -** a mutex is held. A 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 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 with -** [sqlite3_result_value()] and [sqlite3_bind_value()]. -** The [sqlite3_value_blob | sqlite3_value_type()] family of -** interfaces require protected sqlite3_value objects. -*/ -typedef struct Mem 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} -** -** ^(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: -** -**
    -**
  • ? -**
  • ?NNN -**
  • :VVV -**
  • @VVV -**
  • $VVV -**
-** -** In the templates above, NNN represents an integer literal, -** and VVV represents an alphanumeric identifer.)^ ^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: 999). -** -** ^The third argument is the value to bind to the parameter. -** -** ^(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 is negative, the length of the string is -** the number of bytes up to the first zero terminator. -** -** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and -** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^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 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. -** -** ^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_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_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 n, void(*)(void*)); -SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); -SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); -SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); - -/* -** CAPI3REF: Number Of SQL Parameters -** -** ^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 -** -** ^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()] or -** [sqlite3_prepare16_v2()]. -** -** 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 -** -** ^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()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); - -/* -** CAPI3REF: Reset All Bindings On A Prepared Statement -** -** ^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 -** -** ^Return the number of columns in the result set returned by the -** [prepared statement]. ^This routine returns 0 if pStmt is an SQL -** statement that does not return data (for example an [UPDATE]). -*/ -SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Column Names In A Result Set -** -** ^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 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 -** -** ^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 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 routine 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 of these routines against the same -** prepared statement and column at the same time then the results are -** undefined. -** -** 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 -** -** ^(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 -** -** After a [prepared statement] has been prepared using either -** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] 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 "v2" interface -** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy -** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the -** new "v2" 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 a -** 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. -** -** 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 either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] 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 "v2" interface is recommended. -*/ -SQLITE_API int sqlite3_step(sqlite3_stmt*); - -/* -** CAPI3REF: Number of columns in a result set -** -** ^The sqlite3_data_count(P) the number of columns in the -** of the result set of [prepared statement] P. -*/ -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: -** -**
    -**
  • 64-bit signed integer -**
  • 64-bit IEEE floating point number -**
  • string -**
  • BLOB -**
  • NULL -**
)^ -** -** 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} -** -** These routines form the "result set" interface. -** -** ^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 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 value -** returned by sqlite3_column_type() is only meaningful if no type -** conversions have occurred as described below. After a type conversion, -** the value returned by sqlite3_column_type() is undefined. Future -** versions of SQLite may change the behavior of sqlite3_column_type() -** following a type conversion. -** -** ^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. -** ^The value returned does not include the zero terminator at the end -** of the string. ^For clarity: the value returned is 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 an arbitrary -** pointer, possibly even a NULL pointer. -** -** ^The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() -** but leaves the result in UTF-16 in native byte order instead of UTF-8. -** ^The zero terminator is not included in this count. -** -** ^The object returned by [sqlite3_column_value()] is an -** [unprotected sqlite3_value] object. An unprotected sqlite3_value object -** may only be used 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()], then the behavior is undefined. -** -** These routines attempt to convert the value where appropriate. ^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 NULL pointer -**
NULL BLOB Result is NULL pointer -**
INTEGER FLOAT Convert from integer to float -**
INTEGER TEXT ASCII rendering of the integer -**
INTEGER BLOB Same as INTEGER->TEXT -**
FLOAT INTEGER Convert from float to integer -**
FLOAT TEXT ASCII rendering of the float -**
FLOAT BLOB Same as FLOAT->TEXT -**
TEXT INTEGER Use atoi() -**
TEXT FLOAT Use atof() -**
TEXT BLOB No change -**
BLOB INTEGER Convert to TEXT then use atoi() -**
BLOB FLOAT Convert to TEXT then use atof() -**
BLOB TEXT Add a zero terminator if needed -**
-**
)^ -** -** The table above makes reference to standard C library functions atoi() -** and atof(). SQLite does not really use these functions. It has its -** own equivalent internal routines. The atoi() and atof() names are -** used in the table for brevity and because they are familiar to most -** C programmers. -** -** ^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: -** -**
    -**
  • The initial content is a BLOB and sqlite3_column_text() or -** sqlite3_column_text16() is called. A zero-terminator might -** need to be added to the string.
    • -**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or -** sqlite3_column_text16() is called. The content must be converted -** to UTF-16.
    • -**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or -** sqlite3_column_text() is called. The content must be converted -** to UTF-8.
    • -**
)^ -** -** ^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 points to 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 and easiest to remember policy is to invoke these routines -** in one of the following ways: -** -**
    -**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • -**
)^ -** -** 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 -** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into -** [sqlite3_free()]. -** -** ^(If a memory allocation error occurs during the evaluation of any -** of these routines, a default value is returned. The default value -** is either the integer 0, the floating point number 0.0, or a NULL -** pointer. Subsequent calls to [sqlite3_errcode()] will return -** [SQLITE_NOMEM].)^ -*/ -SQLITE_API const void *sqlite3_column_blob(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 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 int sqlite3_column_type(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); - -/* -** CAPI3REF: Destroy A Prepared Statement Object -** -** ^The sqlite3_finalize() function is called to delete a [prepared statement]. -** ^If the statement was executed successfully or not executed at all, then -** SQLITE_OK is returned. ^If execution of the statement failed then an -** [error code] or [extended error code] is returned. -** -** ^This routine can be called at any point during the execution of the -** [prepared statement]. ^If the virtual machine has not -** completed execution when this routine is called, that is like -** encountering an error or an [sqlite3_interrupt | interrupt]. -** ^Incomplete updates may be rolled back and transactions canceled, -** depending on the circumstances, and the -** [error code] returned will be [SQLITE_ABORT]. -*/ -SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Reset A Prepared Statement Object -** -** 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} -** KEYWORDS: {application-defined SQL function} -** KEYWORDS: {application-defined SQL functions} -** -** ^These two 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 difference between the -** two is that the second parameter, the name of the (scalar) function or -** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16 -** for sqlite3_create_function16(). -** -** ^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, exclusive of -** the zero-terminator. Note that the name length limit is in bytes, not -** characters. ^Any attempt to create a function with a longer name -** will result in [SQLITE_ERROR] 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. Any SQL function implementation should be able to work -** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be -** more efficient with one encoding than another. ^An application may -** invoke sqlite3_create_function() or sqlite3_create_function16() multiple -** times with the same function but with different values of eTextRep. -** ^When multiple implementations of the same function are available, SQLite -** will pick the one that involves the least amount of data conversion. -** If there is only a single implementation which does not care what text -** encoding is used, then the fourth argument should be [SQLITE_ANY]. -** -** ^(The fifth parameter is an arbitrary pointer. The implementation of the -** function can gain access to this pointer using [sqlite3_user_data()].)^ -** -** The seventh, eighth and ninth parameters, 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 should be passed as the xStep and xFinal -** parameters. ^An aggregate SQL function requires an implementation of xStep -** and xFinal and NULL should be passed for xFunc. ^To delete an existing -** SQL function or aggregate, pass NULL for all three function callbacks. -** -** ^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. -** ^The first application-defined function with a given name overrides all -** built-in functions in the same [database connection] with the same name. -** ^Subsequent application-defined functions of the same name only override -** prior application-defined functions that are an exact match for the -** number of parameters and preferred encoding. -** -** ^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*) -); - -/* -** CAPI3REF: Text Encodings -** -** These constant define integer codes that represent the various -** text encodings supported by SQLite. -*/ -#define SQLITE_UTF8 1 -#define SQLITE_UTF16LE 2 -#define SQLITE_UTF16BE 3 -#define SQLITE_UTF16 4 /* Use native byte order */ -#define SQLITE_ANY 5 /* sqlite3_create_function only */ -#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ - -/* -** 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 help encourage people to avoid -** using these functions, we are not going to tell you 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 Function Parameter Values -** -** The C-language implementation of SQL functions and aggregates uses -** this set of interface routines to access the parameter values on -** the function or aggregate. -** -** The xFunc (for scalar functions) or xStep (for aggregates) parameters -** to [sqlite3_create_function()] and [sqlite3_create_function16()] -** define callbacks that implement the SQL functions and aggregates. -** The 4th parameter to these callbacks is an array of pointers to -** [protected sqlite3_value] objects. There is one [sqlite3_value] object for -** each parameter to the SQL function. These routines are used to -** extract values from the [sqlite3_value] objects. -** -** These routines work only with [protected sqlite3_value] objects. -** Any attempt to use these routines on an [unprotected sqlite3_value] -** object results in undefined behavior. -** -** ^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. -** -** ^(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.)^ -** -** 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. -*/ -SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes16(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 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_type(sqlite3_value*); -SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); - -/* -** CAPI3REF: Obtain Aggregate Function Context -** -** Implementions 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 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 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 subsequent call to sqlite3_aggregate_context() within -** the same aggregate function instance will not resize the memory -** allocation.)^ -** -** ^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 -** -** ^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 -** -** ^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 -** -** The following two functions may be used by scalar 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. This may -** be used, for example, to add a regular-expression matching scalar -** function. The compiled version of the regular expression is stored as -** metadata associated with the SQL value passed as the regular expression -** pattern. The compiled regular expression can be reused on multiple -** invocations of the same function so that the original pattern string -** does not need to be recompiled on each invocation. -** -** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata -** associated by the sqlite3_set_auxdata() function with the Nth argument -** value to the application-defined function. ^If no metadata has been ever -** been set for the Nth argument of the function, or if the corresponding -** function parameter has changed since the meta-data was set, -** then sqlite3_get_auxdata() returns a NULL pointer. -** -** ^The sqlite3_set_auxdata() interface saves the metadata -** pointed to by its 3rd parameter as the metadata for the N-th -** argument of the application-defined function. Subsequent -** calls to sqlite3_get_auxdata() might return this data, if it has -** not been destroyed. -** ^If it is not NULL, SQLite will invoke the destructor -** function given by the 4th parameter to sqlite3_set_auxdata() on -** the metadata when the corresponding function parameter changes -** or when the SQL statement completes, whichever comes first. -** -** SQLite is free to call the destructor and drop metadata on any -** parameter of any function at any time. ^The only guarantee is that -** the destructor will be called before the metadata is dropped. -** -** ^(In practice, metadata is preserved between function calls for -** expressions that are constant at compile time. This includes literal -** values and [parameters].)^ -** -** 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. See ticket #2191. -*/ -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 -** -** 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() interfaces set the result of -** the application-defined function to be a BLOB containing all zero -** bytes and N bytes in size, where N is the value of the 2nd parameter. -** -** ^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 in native -** byte order. ^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_toobig() interface causes SQLite to throw an error -** indicating that a string or BLOB is too long to represent. -** -** ^The sqlite3_result_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. -** ^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 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 -** from [sqlite3_malloc()] before it returns. -** -** ^The sqlite3_result_value() interface sets the result of -** the application-defined function to be a copy 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. -** -** 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_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_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_zeroblob(sqlite3_context*, int n); - -/* -** CAPI3REF: Define New Collating Sequences -** -** These functions are used to add new collation sequences to the -** [database connection] specified as the first argument. -** -** ^The name of the new collation sequence is specified as a UTF-8 string -** for sqlite3_create_collation() and sqlite3_create_collation_v2() -** and a UTF-16 string for sqlite3_create_collation16(). ^In all cases -** the name is passed as the second function argument. -** -** ^The third argument may be one of the constants [SQLITE_UTF8], -** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied -** routine expects to be passed pointers to strings encoded using UTF-8, -** UTF-16 little-endian, or UTF-16 big-endian, respectively. ^The -** third argument might also be [SQLITE_UTF16] to indicate that the routine -** expects pointers to be UTF-16 strings in the native byte order, or the -** argument can be [SQLITE_UTF16_ALIGNED] if the -** the routine expects pointers to 16-bit word aligned strings -** of UTF-16 in the native byte order. -** -** A pointer to the user supplied routine must be passed as the fifth -** argument. ^If it is NULL, this is the same as deleting the collation -** sequence (so that SQLite cannot call it anymore). -** ^Each time the application supplied function is invoked, it is passed -** as its first parameter a copy of the void* passed as the fourth argument -** to sqlite3_create_collation() or sqlite3_create_collation16(). -** -** ^The remaining arguments to the application-supplied routine are two strings, -** each represented by a (length, data) pair and encoded in the encoding -** that was passed as the third argument when the collation sequence was -** registered. The application defined collation routine should -** return negative, zero or positive if the first string is less than, -** equal to, or greater than the second string. i.e. (STRING1 - STRING2). -** -** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() -** except that it takes an extra argument which is a destructor for -** the collation. ^The destructor is called when the collation is -** destroyed and is passed a copy of the fourth parameter void* pointer -** of the sqlite3_create_collation_v2(). -** ^Collations are destroyed when they are overridden by later calls to the -** collation creation functions or when the [database connection] is closed -** using [sqlite3_close()]. -** -** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. -*/ -SQLITE_API int sqlite3_create_collation( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); -SQLITE_API int sqlite3_create_collation_v2( - sqlite3*, - const char *zName, - int eTextRep, - void*, - 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*, - int(*xCompare)(void*,int,const void*,int,const void*) -); - -/* -** CAPI3REF: Collation Needed Callbacks -** -** ^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*) -); - -#if SQLITE_HAS_CODEC -/* -** Specify the key for an encrypted database. This routine should be -** called right after sqlite3_open(). -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_key( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The key */ -); - -/* -** Change the key on an open database. If the current database is not -** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the -** database is decrypted. -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_rekey( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The new key */ -); - -/* -** Specify the activation key for a SEE database. Unless -** activated, none of the SEE routines will work. -*/ -SQLITE_API void sqlite3_activate_see( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -#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. -*/ -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. -** -** 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. -*/ -SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory; - -/* -** CAPI3REF: Test For Auto-Commit Mode -** KEYWORDS: {autocommit mode} -** -** ^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 -** -** ^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: Find the next prepared statement -** -** ^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 -** -** ^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 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 [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** 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. -** ^The rollback callback is not invoked if a transaction is -** rolled back because a commit callback returned non-zero. -** -** 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 -** -** ^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. -** ^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. -** ^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_master and sqlite_sequence).)^ -** -** ^In the current implementation, the update hook -** is not invoked when duplication 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()] and [sqlite3_rollback_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 -** KEYWORDS: {shared 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. 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 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. But this might change in -** future releases of SQLite. Applications that care about shared -** cache setting should set it explicitly. -** -** 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. -*/ -SQLITE_API int sqlite3_release_memory(int); - -/* -** CAPI3REF: Impose A Limit On Heap Size -** -** ^The sqlite3_soft_heap_limit() interface places a "soft" limit -** on the amount of heap memory that may be allocated by SQLite. -** ^If an internal allocation is requested that would exceed the -** soft heap limit, [sqlite3_release_memory()] is invoked one or -** more times to free up some space before the allocation is performed. -** -** ^The limit is called "soft" because if [sqlite3_release_memory()] -** cannot free sufficient memory to prevent the limit from being exceeded, -** the memory is allocated anyway and the current operation proceeds. -** -** ^A negative or zero value for N means that there is no soft heap limit and -** [sqlite3_release_memory()] will only be called when memory is exhausted. -** ^The default value for the soft heap limit is zero. -** -** ^(SQLite makes a best effort to honor the soft heap limit. -** But if the soft heap limit cannot be honored, execution will -** continue without error or notification.)^ This is why the limit is -** called a "soft" limit. It is advisory only. -** -** Prior to SQLite version 3.5.0, this routine only constrained the memory -** allocated by a single thread - the same thread in which this routine -** runs. Beginning with SQLite version 3.5.0, the soft heap limit is -** applied to all threads. The value specified for the soft heap limit -** is an upper bound on the total memory allocation for all threads. In -** version 3.5.0 there is no mechanism for limiting the heap usage for -** individual threads. -*/ -SQLITE_API void sqlite3_soft_heap_limit(int); - -/* -** CAPI3REF: Extract Metadata About A Column Of A Table -** -** ^This routine returns metadata about a specific column of a specific -** database table accessible using the [database connection] handle -** passed as the first function argument. -** -** ^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. Neither of these parameters -** may be NULL. -** -** ^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 only 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 an -** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output -** parameters are set for the explicitly declared column. ^(If there is no -** explicitly declared [INTEGER PRIMARY KEY] column, then the output -** parameters are set as follows: -** -** 
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-**
)^ -** -** ^(This function may load one or more schemas from database files. If an -** error occurs during this process, or if the requested table or column -** cannot be found, an [error code] is returned and an error message left -** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ -** -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. -*/ -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 -** -** ^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. -** -** ^The entry point is zProc. -** ^zProc may be 0, in which case the name of the entry point -** defaults to "sqlite3_extension_init". -** ^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()] prior to calling this API, -** otherwise an error will be returned. -** -** 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 -** -** ^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. See ticket #1863. -** ^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. -*/ -SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); - -/* -** CAPI3REF: Automatically Load An Extensions -** -** ^This API can be invoked at program startup in order to register -** one or more statically linked extensions that will be available -** to all new [database connections]. -** -** ^(This routine stores a pointer to the extension entry point -** in an array that is obtained from [sqlite3_malloc()]. That memory -** is deallocated by [sqlite3_reset_auto_extension()].)^ -** -** ^This function registers an extension entry point that is -** automatically invoked whenever a new [database connection] -** is opened using [sqlite3_open()], [sqlite3_open16()], -** or [sqlite3_open_v2()]. -** ^Duplicate extensions are detected so calling this routine -** multiple times with the same extension is harmless. -** ^Automatic extensions apply across all threads. -*/ -SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); - -/* -** CAPI3REF: Reset Automatic Extension Loading -** -** ^(This function disables all previously registered automatic -** extensions. It undoes the effect of all prior -** [sqlite3_auto_extension()] calls.)^ -** -** ^This function disables automatic extensions in all threads. -*/ -SQLITE_API void sqlite3_reset_auto_extension(void); - -/* -****** EXPERIMENTAL - subject to change without notice ************** -** -** 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} -** EXPERIMENTAL -** -** This structure, sometimes called a a "virtual table module", -** defines the implementation of a [virtual tables]. -** 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); -}; - -/* -** CAPI3REF: Virtual Table Indexing Information -** KEYWORDS: sqlite3_index_info -** EXPERIMENTAL -** -** The sqlite3_index_info structure and its substructures is used 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.)^ ^(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 [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 is not checked again by SQLite.)^ -** -** ^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 doing the -** particular lookup. A full scan of a table with N entries should have -** a cost of N. A binary search of a table of N entries should have a -** cost of approximately log(N). -*/ -struct sqlite3_index_info { - /* Inputs */ - int nConstraint; /* Number of entries in aConstraint */ - struct sqlite3_index_constraint { - int iColumn; /* Column on left-hand side of constraint */ - 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 */ -}; -#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 - -/* -** CAPI3REF: Register A Virtual Table Implementation -** EXPERIMENTAL -** -** ^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 sqlite3_create_module() -** interface is equivalent to sqlite3_create_module_v2() with a NULL -** destructor. -*/ -SQLITE_API SQLITE_EXPERIMENTAL 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 SQLITE_EXPERIMENTAL 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: Virtual Table Instance Object -** KEYWORDS: sqlite3_vtab -** EXPERIMENTAL -** -** 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; /* NO LONGER USED */ - 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} -** EXPERIMENTAL -** -** 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 -** EXPERIMENTAL -** -** ^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 SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL); - -/* -** CAPI3REF: Overload A Function For A Virtual Table -** EXPERIMENTAL -** -** ^(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 SQLITE_EXPERIMENTAL 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. -** -****** EXPERIMENTAL - subject to change without notice ************** -*/ - -/* -** 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 -** -** ^(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;
-**
)^ -** -** ^If the flags parameter is non-zero, then the BLOB is opened for read -** and write access. ^If it is zero, the BLOB is opened for read access. -** ^It is not possible to open a column that is part of an index or primary -** key for writing. ^If [foreign key constraints] are enabled, it is -** not possible to open a column that is part of a [child key] for writing. -** -** ^Note that the database name is not the filename that contains -** the database but rather the symbolic name of the database that -** appears after the AS keyword when the database is connected using [ATTACH]. -** ^For the main database file, the database name is "main". -** ^For TEMP tables, the database name is "temp". -** -** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written -** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set -** to be a null pointer.)^ -** ^This function sets the [database connection] error code and message -** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related -** functions. ^Note that the *ppBlob variable is always initialized in a -** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob -** regardless of the success or failure of this routine. -** -** ^(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 -** a expired BLOB handle fail with an 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 can be used, if desired, -** to create an empty, zero-filled blob in which to read or write using -** this interface. -** -** To avoid a resource leak, every open [BLOB handle] should eventually -** be released by a call to [sqlite3_blob_close()]. -*/ -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: Close A BLOB Handle -** -** ^Closes an open [BLOB handle]. -** -** ^Closing a BLOB shall cause the current transaction to commit -** if there are no other BLOBs, no pending prepared statements, and the -** database connection is in [autocommit mode]. -** ^If any writes were made to the BLOB, they might be held in cache -** until the close operation if they will fit. -** -** ^(Closing the BLOB often forces the changes -** out to disk and so if any I/O errors occur, they will likely occur -** at the time when the BLOB is closed. Any errors that occur during -** closing are reported as a non-zero return value.)^ -** -** ^(The BLOB is closed unconditionally. Even if this routine returns -** an error code, the BLOB is still closed.)^ -** -** ^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. -*/ -SQLITE_API int sqlite3_blob_close(sqlite3_blob *); - -/* -** CAPI3REF: Return The Size Of An Open 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 -** -** ^(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 -** -** ^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. -** -** ^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. ^If N is -** less than zero [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. -** -** ^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. -** -** ^(On success, sqlite3_blob_write() 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_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_OS2 -**
  • SQLITE_MUTEX_PTHREAD -**
  • 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_OS2, -** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations -** are appropriate for use on OS/2, 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. ^If it returns NULL -** that means that a mutex could not be allocated. ^SQLite -** will unwind its stack and return an error. ^(The argument -** to sqlite3_mutex_alloc() is one of these integer constants: -** -**
    -**
  • SQLITE_MUTEX_FAST -**
  • SQLITE_MUTEX_RECURSIVE -**
  • SQLITE_MUTEX_STATIC_MASTER -**
  • SQLITE_MUTEX_STATIC_MEM -**
  • SQLITE_MUTEX_STATIC_MEM2 -**
  • SQLITE_MUTEX_STATIC_PRNG -**
  • SQLITE_MUTEX_STATIC_LRU -**
  • SQLITE_MUTEX_STATIC_LRU2 -**
)^ -** -** ^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. ^Six 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. ^But 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. ^SQLite is careful to deallocate every -** dynamic mutex that it allocates. The dynamic mutexes must not be in -** use when they are deallocated. Attempting to deallocate a static -** mutex results in undefined behavior. ^SQLite never deallocates -** a static mutex. -** -** ^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 other -** kind of mutex more than once, the behavior is undefined. -** SQLite will never exhibit -** such behavior in its own use of mutexes.)^ -** -** ^(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. SQLite will -** never do either.)^ -** -** ^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 -** EXPERIMENTAL -** -** 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 user 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 user -** 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 calle 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() mutiple 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 provided 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 -** 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_MASTER 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_random() */ -#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ -#define SQLITE_MUTEX_STATIC_LRU2 7 /* lru page list */ - -/* -** CAPI3REF: Retrieve the mutex for a database connection -** -** ^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 -** -** ^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 "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. -** -** ^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: [SQLITE_FCNTL_LOCKSTATE] -*/ -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 -#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 -#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 -#define SQLITE_TESTCTRL_ISKEYWORD 16 -#define SQLITE_TESTCTRL_LAST 16 - -/* -** CAPI3REF: SQLite Runtime Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about the preformance 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 [SQLITE_STATUS_MEMORY_USED | 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_db_status() routine returns SQLITE_OK on success and a -** non-zero [error code] on failure. -** -** This routine is threadsafe but is not atomic. This routine can be -** called while other threads are running the same or different SQLite -** interfaces. However the values returned in *pCurrent and -** *pHighwater reflect the status of SQLite at different points in time -** and it is possible that another thread might change the parameter -** in between the times when *pCurrent and *pHighwater are written. -** -** See also: [sqlite3_db_status()] -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); - - -/* -** CAPI3REF: Status Parameters -** EXPERIMENTAL -** -** These integer constants designate various run-time status parameters -** that can be returned by [sqlite3_status()]. -** -**
-** ^(
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. Scratch memory -** controlled by [SQLITE_CONFIG_SCRATCH] and 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
-**
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_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
-**
This parameter returns the number of bytes of page cache -** allocation which could not be statisfied 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
-**
This parameter records the largest memory allocation request -** handed to [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
-**
This parameter returns the number of allocations used out of the -** [scratch memory allocator] configured using -** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not -** in bytes. Since a single thread may only have one scratch allocation -** outstanding at time, this parameter also reports the number of threads -** using scratch memory at the same time.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
-**
This parameter returns the number of bytes of scratch memory -** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH] -** buffer and where forced to overflow to [sqlite3_malloc()]. The values -** returned include overflows because the requested allocation was too -** larger (that is, because the requested allocation was larger than the -** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer -** slots were available. -**
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_SIZE
-**
This parameter records the largest memory allocation request -** handed to [scratch 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_PARSER_STACK
-**
This parameter records the deepest parser stack. It 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 -#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 -#define SQLITE_STATUS_MALLOC_SIZE 5 -#define SQLITE_STATUS_PARSER_STACK 6 -#define SQLITE_STATUS_PAGECACHE_SIZE 7 -#define SQLITE_STATUS_SCRATCH_SIZE 8 - -/* -** CAPI3REF: Database Connection Status -** EXPERIMENTAL -** -** ^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 the parameter to interrogate. ^Currently, the only allowed value -** for the second parameter is [SQLITE_DBSTATUS_LOOKASIDE_USED]. -** Additional options will likely appear 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. -** -** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); - -/* -** CAPI3REF: Status Parameters for database connections -** EXPERIMENTAL -** -** 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
-**
This parameter returns the number of lookaside memory slots currently -** checked out.
)^ -**
-*/ -#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 - - -/* -** CAPI3REF: Prepared Statement Status -** EXPERIMENTAL -** -** ^(Each prepared statement maintains various -** [SQLITE_STMTSTATUS_SORT | 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_SORT | 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 SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); - -/* -** CAPI3REF: Status Parameters for prepared statements -** EXPERIMENTAL -** -** 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
-**
^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
-**
^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.
-** -**
-*/ -#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 -#define SQLITE_STMTSTATUS_SORT 2 - -/* -** CAPI3REF: Custom Page Cache Object -** EXPERIMENTAL -** -** 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_methods] for additional information. -*/ -typedef struct sqlite3_pcache sqlite3_pcache; - -/* -** CAPI3REF: Application Defined Page Cache. -** KEYWORDS: {page cache} -** EXPERIMENTAL -** -** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can -** register an alternative page cache implementation by passing in an -** instance of the sqlite3_pcache_methods structure.)^ The majority of the -** heap memory used by SQLite is used by the page cache to cache data read -** from, or ready to be written to, the database file. By implementing a -** custom page cache using this API, an application can control more -** precisely 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 contents of the sqlite3_pcache_methods 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() method is called once for each call to [sqlite3_initialize()] -** (usually only once during the lifetime of the process). ^(The xInit() -** method is passed a copy of the sqlite3_pcache_methods.pArg value.)^ -** ^The xInit() method can set up up global structures and/or any mutexes -** required by the custom page cache implementation. -** -** ^The xShutdown() method is called from within [sqlite3_shutdown()], -** if the application invokes this API. It can be used to clean up -** any outstanding resources before process shutdown, if required. -** -** ^SQLite holds a [SQLITE_MUTEX_RECURSIVE] 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. 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() method is used 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 not be a power of two. ^szPage -** will the page size of the database file that is to be cached plus an -** increment (here called "R") of about 100 or 200. ^SQLite will use the -** extra R bytes on each page to store metadata about the underlying -** database page on disk. The value of R depends -** on the SQLite version, the target platform, and how SQLite was compiled. -** ^R is constant for a particular build of SQLite. ^The second 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, a cache created with bPurgeable set to false will -** never contain any unpinned pages. -** -** ^(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() method should return the number of pages currently -** stored in the cache. -** -** ^The xFetch() method is used to fetch a page and return a pointer to it. -** ^A 'page', in this context, is a buffer of szPage bytes aligned at an -** 8-byte boundary. ^The page to be fetched is determined by the key. ^The -** mimimum 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 -** behavior of the cache implementation is determined by the value of the -** createFlag parameter passed to xFetch, according to the following table: -** -** -**
createFlag Behaviour 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. If -** a call to xFetch() with createFlag==1 returns NULL, then SQLite will -** attempt to unpin one or more cache pages by spilling the content of -** pinned pages to disk and synching the operating system disk cache. After -** attempting to unpin pages, the xFetch() method will be invoked again with -** a createFlag of 2. -** -** ^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 should be evicted from the cache. In this case SQLite -** assumes that the next time the page is retrieved from the cache using -** the xFetch() method, it will be zeroed.)^ ^If the discard parameter is -** zero, then the page is considered to be unpinned. ^The cache implementation -** may choose to evict unpinned pages at any time. -** -** ^(The cache is not required to perform any reference counting. A single -** call to xUnpin() unpins the page regardless of the number of prior calls -** to xFetch().)^ -** -** ^The xRekey() method is used to change the key value associated with the -** page passed as the second argument from oldKey to newKey. ^If the cache -** previously contains an entry associated with newKey, it should 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() 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_methods -** functions. -*/ -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 -** EXPERIMENTAL -** -** 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. -** EXPERIMENTAL -** -** 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] -** -** ^Exclusive access is required to the destination database for the -** duration of the operation. ^However the source database is only -** read-locked while it is actually 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 users 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() -** -** ^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 file with -** an error. -** -** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is -** returned and an error code and error message are store3d 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() -** -** ^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 resturns [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 the destination -** database was opened read-only or if -** the destination is an in-memory database with a different page size -** from the source database. -** -** ^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() -** -** 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() -** -** ^Each call to sqlite3_backup_step() sets two values inside -** the [sqlite3_backup] object: the number of pages still to be backed -** up and the total number of pages in the source databae file. -** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces -** retrieve these two values, respectively. -** -** ^The values returned by these functions are only updated by -** sqlite3_backup_step(). ^If the source database is modified during a backup -** operation, then the values are not updated to account for any extra -** pages that need to be updated or the size of the source database file -** changing. -** -** 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 -** EXPERIMENTAL -** -** ^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 connections 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 cancelled. ^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 connections 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 -** EXPERIMENTAL -** -** ^The [sqlite3_strnicmp()] API allows applications and extensions to -** compare the contents of two buffers containing UTF-8 strings in a -** case-indendent fashion, using the same definition of case independence -** that SQLite uses internally when comparing identifiers. -*/ -SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); - -/* -** CAPI3REF: Error Logging Interface -** EXPERIMENTAL -** -** ^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 -** passed through to [sqlite3_vmprintf()] 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, ...); - -/* -** 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 - diff --git a/win32/sqlite3.lib b/win32/sqlite3.lib deleted file mode 100644 index 160223f6da8d6051774756c61468be85e39f5783..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41644 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 diff --git a/win64/CMakeLists.txt b/win64/CMakeLists.txt deleted file mode 100644 index 0903896..0000000 --- a/win64/CMakeLists.txt +++ /dev/null @@ -1,30 +0,0 @@ -# --------------------------------------------------------------------- -# -# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image -# pour la Santé) -# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton -# Previous Authors : Laurent Guigues, Jean-Pierre Roux -# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil -# -# This software is governed by the CeCILL-B license under French law and -# abiding by the rules of distribution of free software. You can use, -# modify and/ or redistribute the software under the terms of the CeCILL-B -# license as circulated by CEA, CNRS and INRIA at the following URL -# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html -# or in the file LICENSE.txt. -# -# As a counterpart to the access to the source code and rights to copy, -# modify and redistribute granted by the license, users are provided only -# with a limited warranty and the software's author, the holder of the -# economic rights, and the successive licensors have only limited -# liability. -# -# The fact that you are presently reading this means that you have had -# knowledge of the CeCILL-B license and that you accept its terms. -# ------------------------------------------------------------------------ - -IF (WIN32) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Debug/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Release/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/RelWithDebInfo/sqlite3.dll COPYONLY) -ENDIF(WIN32) \ No newline at end of file diff --git a/win64/sqlite/CMakeLists.txt b/win64/sqlite/CMakeLists.txt deleted file mode 100644 index 558a32e..0000000 --- a/win64/sqlite/CMakeLists.txt +++ /dev/null @@ -1,37 +0,0 @@ -cmake_minimum_required ( VERSION 2.6 FATAL_ERROR ) - -project ( sqlite3 C ) - -SET( CMAKE_INSTALL_PREFIX "" ) - -set ( SOURCES sqlite3.c ) -set ( HEADERS sqlite3.h ) - -if ( WIN32 ) - if ( MSVC ) -# set ( CMAKE_SHARED_LINKER_FLAGS /DEF:sqlite3.def ) -# set ( SQLITE3_DEF_FILE "${CMAKE_CURRENT_BINARY_DIR}/sqlite3.def" ) - add_definitions( "-DSQLITE_API=__declspec(dllexport)" ) - endif ( MSVC ) -endif ( WIN32 ) - - FIND_PACKAGE(GDCM REQUIRED) - INCLUDE_DIRECTORIES(${GDCM_INCLUDE_DIRS}) - - -# ${GDCM_DIR}/bin/Debug/gdcmDSED.lib - # ${GDCM_DIR}/bin/Debug/gdcmMSFF.lib) - -add_library ( sqlite3 SHARED - ${SOURCES} - ${HEADERS} - gdcmDSED.lib -) - -INSTALL ( TARGETS sqlite3 - RUNTIME DESTINATION bin - LIBRARY DESTINATION lib - ARCHIVE DESTINATION lib -) - -INSTALL ( FILES sqlite3.h DESTINATION include ) diff --git a/win64/sqlite/Readme.txt b/win64/sqlite/Readme.txt deleted file mode 100644 index 82ed146..0000000 --- a/win64/sqlite/Readme.txt +++ /dev/null @@ -1,18 +0,0 @@ -//////////////////////////////////////////// -// README // -//////////////////////////////////////////// - -If you need to rebuild sqlite library (.lib and .dll), -Use the associated CMakeLists file to generate a sqlite project with the right compilator (x64 or x86). -Check on SQLITE website if a new version of sqlite is not avaialble. -http://www.sqlite.org/download.html - -!!! IMPORTANT : you just need to download amalgation package and replace files : -shell.c -sqlite3.c -sqlite.h -sqlite3ext.h -sqlite3.def - -(last version 3.6.23.1) - diff --git a/win64/sqlite/shell.c b/win64/sqlite/shell.c deleted file mode 100644 index a1c0b5e..0000000 --- a/win64/sqlite/shell.c +++ /dev/null @@ -1,2635 +0,0 @@ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This file contains code to implement the "sqlite" command line -** utility for accessing SQLite databases. -*/ -#if defined(_WIN32) || defined(WIN32) -/* This needs to come before any includes for MSVC compiler */ -#define _CRT_SECURE_NO_WARNINGS -#endif - -#include -#include -#include -#include -#include "sqlite3.h" -#include -#include - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) -# include -# if !defined(__RTP__) && !defined(_WRS_KERNEL) -# include -# endif -# include -# include -#endif - -#ifdef __OS2__ -# include -#endif - -#if defined(HAVE_READLINE) && HAVE_READLINE==1 -# include -# include -#else -# define readline(p) local_getline(p,stdin) -# define add_history(X) -# define read_history(X) -# define write_history(X) -# define stifle_history(X) -#endif - -#if defined(_WIN32) || defined(WIN32) -# include -#define isatty(h) _isatty(h) -#define access(f,m) _access((f),(m)) -#else -/* Make sure isatty() has a prototype. -*/ -extern int isatty(); -#endif - -#if defined(_WIN32_WCE) -/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() - * thus we always assume that we have a console. That can be - * overridden with the -batch command line option. - */ -#define isatty(x) 1 -#endif - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(__RTP__) && !defined(_WRS_KERNEL) -#include -#include - -/* Saved resource information for the beginning of an operation */ -static struct rusage sBegin; - -/* True if the timer is enabled */ -static int enableTimer = 0; - -/* -** Begin timing an operation -*/ -static void beginTimer(void){ - if( enableTimer ){ - getrusage(RUSAGE_SELF, &sBegin); - } -} - -/* Return the difference of two time_structs in seconds */ -static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ - return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + - (double)(pEnd->tv_sec - pStart->tv_sec); -} - -/* -** Print the timing results. -*/ -static void endTimer(void){ - if( enableTimer ){ - struct rusage sEnd; - getrusage(RUSAGE_SELF, &sEnd); - printf("CPU Time: user %f sys %f\n", - timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), - timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); - } -} - -#define BEGIN_TIMER beginTimer() -#define END_TIMER endTimer() -#define HAS_TIMER 1 - -#elif (defined(_WIN32) || defined(WIN32)) - -#include - -/* Saved resource information for the beginning of an operation */ -static HANDLE hProcess; -static FILETIME ftKernelBegin; -static FILETIME ftUserBegin; -typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); -static GETPROCTIMES getProcessTimesAddr = NULL; - -/* True if the timer is enabled */ -static int enableTimer = 0; - -/* -** Check to see if we have timer support. Return 1 if necessary -** support found (or found previously). -*/ -static int hasTimer(void){ - if( getProcessTimesAddr ){ - return 1; - } else { - /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions. - ** See if the version we are running on has it, and if it does, save off - ** a pointer to it and the current process handle. - */ - hProcess = GetCurrentProcess(); - if( hProcess ){ - HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); - if( NULL != hinstLib ){ - getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); - if( NULL != getProcessTimesAddr ){ - return 1; - } - FreeLibrary(hinstLib); - } - } - } - return 0; -} - -/* -** Begin timing an operation -*/ -static void beginTimer(void){ - if( enableTimer && getProcessTimesAddr ){ - FILETIME ftCreation, ftExit; - getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin); - } -} - -/* Return the difference of two FILETIME structs in seconds */ -static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ - sqlite_int64 i64Start = *((sqlite_int64 *) pStart); - sqlite_int64 i64End = *((sqlite_int64 *) pEnd); - return (double) ((i64End - i64Start) / 10000000.0); -} - -/* -** Print the timing results. -*/ -static void endTimer(void){ - if( enableTimer && getProcessTimesAddr){ - FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; - getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd); - printf("CPU Time: user %f sys %f\n", - timeDiff(&ftUserBegin, &ftUserEnd), - timeDiff(&ftKernelBegin, &ftKernelEnd)); - } -} - -#define BEGIN_TIMER beginTimer() -#define END_TIMER endTimer() -#define HAS_TIMER hasTimer() - -#else -#define BEGIN_TIMER -#define END_TIMER -#define HAS_TIMER 0 -#endif - -/* -** Used to prevent warnings about unused parameters -*/ -#define UNUSED_PARAMETER(x) (void)(x) - -/* -** If the following flag is set, then command execution stops -** at an error if we are not interactive. -*/ -static int bail_on_error = 0; - -/* -** Threat stdin as an interactive input if the following variable -** is true. Otherwise, assume stdin is connected to a file or pipe. -*/ -static int stdin_is_interactive = 1; - -/* -** The following is the open SQLite database. We make a pointer -** to this database a static variable so that it can be accessed -** by the SIGINT handler to interrupt database processing. -*/ -static sqlite3 *db = 0; - -/* -** True if an interrupt (Control-C) has been received. -*/ -static volatile int seenInterrupt = 0; - -/* -** This is the name of our program. It is set in main(), used -** in a number of other places, mostly for error messages. -*/ -static char *Argv0; - -/* -** Prompt strings. Initialized in main. Settable with -** .prompt main continue -*/ -static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ -static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ - -/* -** Write I/O traces to the following stream. -*/ -#ifdef SQLITE_ENABLE_IOTRACE -static FILE *iotrace = 0; -#endif - -/* -** This routine works like printf in that its first argument is a -** format string and subsequent arguments are values to be substituted -** in place of % fields. The result of formatting this string -** is written to iotrace. -*/ -#ifdef SQLITE_ENABLE_IOTRACE -static void iotracePrintf(const char *zFormat, ...){ - va_list ap; - char *z; - if( iotrace==0 ) return; - va_start(ap, zFormat); - z = sqlite3_vmprintf(zFormat, ap); - va_end(ap); - fprintf(iotrace, "%s", z); - sqlite3_free(z); -} -#endif - - -/* -** Determines if a string is a number of not. -*/ -static int isNumber(const char *z, int *realnum){ - if( *z=='-' || *z=='+' ) z++; - if( !isdigit(*z) ){ - return 0; - } - z++; - if( realnum ) *realnum = 0; - while( isdigit(*z) ){ z++; } - if( *z=='.' ){ - z++; - if( !isdigit(*z) ) return 0; - while( isdigit(*z) ){ z++; } - if( realnum ) *realnum = 1; - } - if( *z=='e' || *z=='E' ){ - z++; - if( *z=='+' || *z=='-' ) z++; - if( !isdigit(*z) ) return 0; - while( isdigit(*z) ){ z++; } - if( realnum ) *realnum = 1; - } - return *z==0; -} - -/* -** A global char* and an SQL function to access its current value -** from within an SQL statement. This program used to use the -** sqlite_exec_printf() API to substitue a string into an SQL statement. -** The correct way to do this with sqlite3 is to use the bind API, but -** since the shell is built around the callback paradigm it would be a lot -** of work. Instead just use this hack, which is quite harmless. -*/ -static const char *zShellStatic = 0; -static void shellstaticFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - assert( 0==argc ); - assert( zShellStatic ); - UNUSED_PARAMETER(argc); - UNUSED_PARAMETER(argv); - sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC); -} - - -/* -** This routine reads a line of text from FILE in, stores -** the text in memory obtained from malloc() and returns a pointer -** to the text. NULL is returned at end of file, or if malloc() -** fails. -** -** The interface is like "readline" but no command-line editing -** is done. -*/ -static char *local_getline(char *zPrompt, FILE *in){ - char *zLine; - int nLine; - int n; - int eol; - - if( zPrompt && *zPrompt ){ - printf("%s",zPrompt); - fflush(stdout); - } - nLine = 100; - zLine = malloc( nLine ); - if( zLine==0 ) return 0; - n = 0; - eol = 0; - while( !eol ){ - if( n+100>nLine ){ - nLine = nLine*2 + 100; - zLine = realloc(zLine, nLine); - if( zLine==0 ) return 0; - } - if( fgets(&zLine[n], nLine - n, in)==0 ){ - if( n==0 ){ - free(zLine); - return 0; - } - zLine[n] = 0; - eol = 1; - break; - } - while( zLine[n] ){ n++; } - if( n>0 && zLine[n-1]=='\n' ){ - n--; - if( n>0 && zLine[n-1]=='\r' ) n--; - zLine[n] = 0; - eol = 1; - } - } - zLine = realloc( zLine, n+1 ); - return zLine; -} - -/* -** Retrieve a single line of input text. -** -** zPrior is a string of prior text retrieved. If not the empty -** string, then issue a continuation prompt. -*/ -static char *one_input_line(const char *zPrior, FILE *in){ - char *zPrompt; - char *zResult; - if( in!=0 ){ - return local_getline(0, in); - } - if( zPrior && zPrior[0] ){ - zPrompt = continuePrompt; - }else{ - zPrompt = mainPrompt; - } - zResult = readline(zPrompt); -#if defined(HAVE_READLINE) && HAVE_READLINE==1 - if( zResult && *zResult ) add_history(zResult); -#endif - return zResult; -} - -struct previous_mode_data { - int valid; /* Is there legit data in here? */ - int mode; - int showHeader; - int colWidth[100]; -}; - -/* -** An pointer to an instance of this structure is passed from -** the main program to the callback. This is used to communicate -** state and mode information. -*/ -struct callback_data { - sqlite3 *db; /* The database */ - int echoOn; /* True to echo input commands */ - int cnt; /* Number of records displayed so far */ - FILE *out; /* Write results here */ - int mode; /* An output mode setting */ - int writableSchema; /* True if PRAGMA writable_schema=ON */ - int showHeader; /* True to show column names in List or Column mode */ - char *zDestTable; /* Name of destination table when MODE_Insert */ - char separator[20]; /* Separator character for MODE_List */ - int colWidth[100]; /* Requested width of each column when in column mode*/ - int actualWidth[100]; /* Actual width of each column */ - char nullvalue[20]; /* The text to print when a NULL comes back from - ** the database */ - struct previous_mode_data explainPrev; - /* Holds the mode information just before - ** .explain ON */ - char outfile[FILENAME_MAX]; /* Filename for *out */ - const char *zDbFilename; /* name of the database file */ - sqlite3_stmt *pStmt; /* Current statement if any. */ - FILE *pLog; /* Write log output here */ -}; - -/* -** These are the allowed modes. -*/ -#define MODE_Line 0 /* One column per line. Blank line between records */ -#define MODE_Column 1 /* One record per line in neat columns */ -#define MODE_List 2 /* One record per line with a separator */ -#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ -#define MODE_Html 4 /* Generate an XHTML table */ -#define MODE_Insert 5 /* Generate SQL "insert" statements */ -#define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */ -#define MODE_Csv 7 /* Quote strings, numbers are plain */ -#define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */ - -static const char *modeDescr[] = { - "line", - "column", - "list", - "semi", - "html", - "insert", - "tcl", - "csv", - "explain", -}; - -/* -** Number of elements in an array -*/ -#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) - -/* -** Compute a string length that is limited to what can be stored in -** lower 30 bits of a 32-bit signed integer. -*/ -static int strlen30(const char *z){ - const char *z2 = z; - while( *z2 ){ z2++; } - return 0x3fffffff & (int)(z2 - z); -} - -/* -** A callback for the sqlite3_log() interface. -*/ -static void shellLog(void *pArg, int iErrCode, const char *zMsg){ - struct callback_data *p = (struct callback_data*)pArg; - if( p->pLog==0 ) return; - fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg); - fflush(p->pLog); -} - -/* -** Output the given string as a hex-encoded blob (eg. X'1234' ) -*/ -static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ - int i; - char *zBlob = (char *)pBlob; - fprintf(out,"X'"); - for(i=0; i0 ){ - fprintf(out,"%.*s",i,z); - } - if( z[i]=='<' ){ - fprintf(out,"<"); - }else if( z[i]=='&' ){ - fprintf(out,"&"); - }else if( z[i]=='>' ){ - fprintf(out,">"); - }else if( z[i]=='\"' ){ - fprintf(out,"""); - }else if( z[i]=='\'' ){ - fprintf(out,"'"); - }else{ - break; - } - z += i + 1; - } -} - -/* -** If a field contains any character identified by a 1 in the following -** array, then the string must be quoted for CSV. -*/ -static const char needCsvQuote[] = { - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -}; - -/* -** Output a single term of CSV. Actually, p->separator is used for -** the separator, which may or may not be a comma. p->nullvalue is -** the null value. Strings are quoted using ANSI-C rules. Numbers -** appear outside of quotes. -*/ -static void output_csv(struct callback_data *p, const char *z, int bSep){ - FILE *out = p->out; - if( z==0 ){ - fprintf(out,"%s",p->nullvalue); - }else{ - int i; - int nSep = strlen30(p->separator); - for(i=0; z[i]; i++){ - if( needCsvQuote[((unsigned char*)z)[i]] - || (z[i]==p->separator[0] && - (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){ - i = 0; - break; - } - } - if( i==0 ){ - putc('"', out); - for(i=0; z[i]; i++){ - if( z[i]=='"' ) putc('"', out); - putc(z[i], out); - } - putc('"', out); - }else{ - fprintf(out, "%s", z); - } - } - if( bSep ){ - fprintf(p->out, "%s", p->separator); - } -} - -#ifdef SIGINT -/* -** This routine runs when the user presses Ctrl-C -*/ -static void interrupt_handler(int NotUsed){ - UNUSED_PARAMETER(NotUsed); - seenInterrupt = 1; - if( db ) sqlite3_interrupt(db); -} -#endif - -/* -** This is the callback routine that the shell -** invokes for each row of a query result. -*/ -static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){ - int i; - struct callback_data *p = (struct callback_data*)pArg; - - switch( p->mode ){ - case MODE_Line: { - int w = 5; - if( azArg==0 ) break; - for(i=0; iw ) w = len; - } - if( p->cnt++>0 ) fprintf(p->out,"\n"); - for(i=0; iout,"%*s = %s\n", w, azCol[i], - azArg[i] ? azArg[i] : p->nullvalue); - } - break; - } - case MODE_Explain: - case MODE_Column: { - if( p->cnt++==0 ){ - for(i=0; icolWidth) ){ - w = p->colWidth[i]; - }else{ - w = 0; - } - if( w<=0 ){ - w = strlen30(azCol[i] ? azCol[i] : ""); - if( w<10 ) w = 10; - n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue); - if( wactualWidth) ){ - p->actualWidth[i] = w; - } - if( p->showHeader ){ - fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " "); - } - } - if( p->showHeader ){ - for(i=0; iactualWidth) ){ - w = p->actualWidth[i]; - }else{ - w = 10; - } - fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------" - "----------------------------------------------------------", - i==nArg-1 ? "\n": " "); - } - } - } - if( azArg==0 ) break; - for(i=0; iactualWidth) ){ - w = p->actualWidth[i]; - }else{ - w = 10; - } - if( p->mode==MODE_Explain && azArg[i] && - strlen30(azArg[i])>w ){ - w = strlen30(azArg[i]); - } - fprintf(p->out,"%-*.*s%s",w,w, - azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " "); - } - break; - } - case MODE_Semi: - case MODE_List: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator); - } - } - if( azArg==0 ) break; - for(i=0; inullvalue; - fprintf(p->out, "%s", z); - if( iout, "%s", p->separator); - }else if( p->mode==MODE_Semi ){ - fprintf(p->out, ";\n"); - }else{ - fprintf(p->out, "\n"); - } - } - break; - } - case MODE_Html: { - if( p->cnt++==0 && p->showHeader ){ - fprintf(p->out,""); - for(i=0; iout,""); - output_html_string(p->out, azCol[i]); - fprintf(p->out,"\n"); - } - fprintf(p->out,"\n"); - } - if( azArg==0 ) break; - fprintf(p->out,""); - for(i=0; iout,""); - output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue); - fprintf(p->out,"\n"); - } - fprintf(p->out,"\n"); - break; - } - case MODE_Tcl: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,azCol[i] ? azCol[i] : ""); - fprintf(p->out, "%s", p->separator); - } - fprintf(p->out,"\n"); - } - if( azArg==0 ) break; - for(i=0; iout, azArg[i] ? azArg[i] : p->nullvalue); - fprintf(p->out, "%s", p->separator); - } - fprintf(p->out,"\n"); - break; - } - case MODE_Csv: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,"\n"); - } - if( azArg==0 ) break; - for(i=0; iout,"\n"); - break; - } - case MODE_Insert: { - p->cnt++; - if( azArg==0 ) break; - fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable); - for(i=0; i0 ? ",": ""; - if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ - fprintf(p->out,"%sNULL",zSep); - }else if( aiType && aiType[i]==SQLITE_TEXT ){ - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_quoted_string(p->out, azArg[i]); - }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){ - fprintf(p->out,"%s%s",zSep, azArg[i]); - }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ - const void *pBlob = sqlite3_column_blob(p->pStmt, i); - int nBlob = sqlite3_column_bytes(p->pStmt, i); - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_hex_blob(p->out, pBlob, nBlob); - }else if( isNumber(azArg[i], 0) ){ - fprintf(p->out,"%s%s",zSep, azArg[i]); - }else{ - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_quoted_string(p->out, azArg[i]); - } - } - fprintf(p->out,");\n"); - break; - } - } - return 0; -} - -/* -** This is the callback routine that the SQLite library -** invokes for each row of a query result. -*/ -static int callback(void *pArg, int nArg, char **azArg, char **azCol){ - /* since we don't have type info, call the shell_callback with a NULL value */ - return shell_callback(pArg, nArg, azArg, azCol, NULL); -} - -/* -** Set the destination table field of the callback_data structure to -** the name of the table given. Escape any quote characters in the -** table name. -*/ -static void set_table_name(struct callback_data *p, const char *zName){ - int i, n; - int needQuote; - char *z; - - if( p->zDestTable ){ - free(p->zDestTable); - p->zDestTable = 0; - } - if( zName==0 ) return; - needQuote = !isalpha((unsigned char)*zName) && *zName!='_'; - for(i=n=0; zName[i]; i++, n++){ - if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){ - needQuote = 1; - if( zName[i]=='\'' ) n++; - } - } - if( needQuote ) n += 2; - z = p->zDestTable = malloc( n+1 ); - if( z==0 ){ - fprintf(stderr,"Error: out of memory\n"); - exit(1); - } - n = 0; - if( needQuote ) z[n++] = '\''; - for(i=0; zName[i]; i++){ - z[n++] = zName[i]; - if( zName[i]=='\'' ) z[n++] = '\''; - } - if( needQuote ) z[n++] = '\''; - z[n] = 0; -} - -/* zIn is either a pointer to a NULL-terminated string in memory obtained -** from malloc(), or a NULL pointer. The string pointed to by zAppend is -** added to zIn, and the result returned in memory obtained from malloc(). -** zIn, if it was not NULL, is freed. -** -** If the third argument, quote, is not '\0', then it is used as a -** quote character for zAppend. -*/ -static char *appendText(char *zIn, char const *zAppend, char quote){ - int len; - int i; - int nAppend = strlen30(zAppend); - int nIn = (zIn?strlen30(zIn):0); - - len = nAppend+nIn+1; - if( quote ){ - len += 2; - for(i=0; iechoOn ){ - const char *zStmtSql = sqlite3_sql(pStmt); - fprintf(pArg->out,"%s\n", zStmtSql ? zStmtSql : zSql); - } - - /* perform the first step. this will tell us if we - ** have a result set or not and how wide it is. - */ - rc = sqlite3_step(pStmt); - /* if we have a result set... */ - if( SQLITE_ROW == rc ){ - /* if we have a callback... */ - if( xCallback ){ - /* allocate space for col name ptr, value ptr, and type */ - int nCol = sqlite3_column_count(pStmt); - void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1); - if( !pData ){ - rc = SQLITE_NOMEM; - }else{ - char **azCols = (char **)pData; /* Names of result columns */ - char **azVals = &azCols[nCol]; /* Results */ - int *aiTypes = (int *)&azVals[nCol]; /* Result types */ - int i; - assert(sizeof(int) <= sizeof(char *)); - /* save off ptrs to column names */ - for(i=0; ipStmt = pStmt; - pArg->cnt = 0; - } - do{ - /* extract the data and data types */ - for(i=0; ipStmt = NULL; - } - } - }else{ - do{ - rc = sqlite3_step(pStmt); - } while( rc == SQLITE_ROW ); - } - } - - /* Finalize the statement just executed. If this fails, save a - ** copy of the error message. Otherwise, set zSql to point to the - ** next statement to execute. */ - rc = sqlite3_finalize(pStmt); - if( rc==SQLITE_OK ){ - zSql = zLeftover; - while( isspace(zSql[0]) ) zSql++; - }else if( pzErrMsg ){ - *pzErrMsg = save_err_msg(db); - } - } - } /* end while */ - - return rc; -} - - -/* -** This is a different callback routine used for dumping the database. -** Each row received by this callback consists of a table name, -** the table type ("index" or "table") and SQL to create the table. -** This routine should print text sufficient to recreate the table. -*/ -static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ - int rc; - const char *zTable; - const char *zType; - const char *zSql; - const char *zPrepStmt = 0; - struct callback_data *p = (struct callback_data *)pArg; - - UNUSED_PARAMETER(azCol); - if( nArg!=3 ) return 1; - zTable = azArg[0]; - zType = azArg[1]; - zSql = azArg[2]; - - if( strcmp(zTable, "sqlite_sequence")==0 ){ - zPrepStmt = "DELETE FROM sqlite_sequence;\n"; - }else if( strcmp(zTable, "sqlite_stat1")==0 ){ - fprintf(p->out, "ANALYZE sqlite_master;\n"); - }else if( strncmp(zTable, "sqlite_", 7)==0 ){ - return 0; - }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ - char *zIns; - if( !p->writableSchema ){ - fprintf(p->out, "PRAGMA writable_schema=ON;\n"); - p->writableSchema = 1; - } - zIns = sqlite3_mprintf( - "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" - "VALUES('table','%q','%q',0,'%q');", - zTable, zTable, zSql); - fprintf(p->out, "%s\n", zIns); - sqlite3_free(zIns); - return 0; - }else{ - fprintf(p->out, "%s;\n", zSql); - } - - if( strcmp(zType, "table")==0 ){ - sqlite3_stmt *pTableInfo = 0; - char *zSelect = 0; - char *zTableInfo = 0; - char *zTmp = 0; - int nRow = 0; - - zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0); - zTableInfo = appendText(zTableInfo, zTable, '"'); - zTableInfo = appendText(zTableInfo, ");", 0); - - rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0); - free(zTableInfo); - if( rc!=SQLITE_OK || !pTableInfo ){ - return 1; - } - - zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0); - zTmp = appendText(zTmp, zTable, '"'); - if( zTmp ){ - zSelect = appendText(zSelect, zTmp, '\''); - } - zSelect = appendText(zSelect, " || ' VALUES(' || ", 0); - rc = sqlite3_step(pTableInfo); - while( rc==SQLITE_ROW ){ - const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1); - zSelect = appendText(zSelect, "quote(", 0); - zSelect = appendText(zSelect, zText, '"'); - rc = sqlite3_step(pTableInfo); - if( rc==SQLITE_ROW ){ - zSelect = appendText(zSelect, ") || ',' || ", 0); - }else{ - zSelect = appendText(zSelect, ") ", 0); - } - nRow++; - } - rc = sqlite3_finalize(pTableInfo); - if( rc!=SQLITE_OK || nRow==0 ){ - free(zSelect); - return 1; - } - zSelect = appendText(zSelect, "|| ')' FROM ", 0); - zSelect = appendText(zSelect, zTable, '"'); - - rc = run_table_dump_query(p->out, p->db, zSelect, zPrepStmt); - if( rc==SQLITE_CORRUPT ){ - zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0); - rc = run_table_dump_query(p->out, p->db, zSelect, 0); - } - if( zSelect ) free(zSelect); - } - return 0; -} - -/* -** Run zQuery. Use dump_callback() as the callback routine so that -** the contents of the query are output as SQL statements. -** -** If we get a SQLITE_CORRUPT error, rerun the query after appending -** "ORDER BY rowid DESC" to the end. -*/ -static int run_schema_dump_query( - struct callback_data *p, - const char *zQuery, - char **pzErrMsg -){ - int rc; - rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg); - if( rc==SQLITE_CORRUPT ){ - char *zQ2; - int len = strlen30(zQuery); - if( pzErrMsg ) sqlite3_free(*pzErrMsg); - zQ2 = malloc( len+100 ); - if( zQ2==0 ) return rc; - sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery); - rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg); - free(zQ2); - } - return rc; -} - -/* -** Text of a help message -*/ -static char zHelp[] = - ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n" - ".bail ON|OFF Stop after hitting an error. Default OFF\n" - ".databases List names and files of attached databases\n" - ".dump ?TABLE? ... Dump the database in an SQL text format\n" - " If TABLE specified, only dump tables matching\n" - " LIKE pattern TABLE.\n" - ".echo ON|OFF Turn command echo on or off\n" - ".exit Exit this program\n" - ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n" - " With no args, it turns EXPLAIN on.\n" - ".header(s) ON|OFF Turn display of headers on or off\n" - ".help Show this message\n" - ".import FILE TABLE Import data from FILE into TABLE\n" - ".indices ?TABLE? Show names of all indices\n" - " If TABLE specified, only show indices for tables\n" - " matching LIKE pattern TABLE.\n" -#ifdef SQLITE_ENABLE_IOTRACE - ".iotrace FILE Enable I/O diagnostic logging to FILE\n" -#endif -#ifndef SQLITE_OMIT_LOAD_EXTENSION - ".load FILE ?ENTRY? Load an extension library\n" -#endif - ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n" - ".mode MODE ?TABLE? Set output mode where MODE is one of:\n" - " csv Comma-separated values\n" - " column Left-aligned columns. (See .width)\n" - " html HTML code\n" - " insert SQL insert statements for TABLE\n" - " line One value per line\n" - " list Values delimited by .separator string\n" - " tabs Tab-separated values\n" - " tcl TCL list elements\n" - ".nullvalue STRING Print STRING in place of NULL values\n" - ".output FILENAME Send output to FILENAME\n" - ".output stdout Send output to the screen\n" - ".prompt MAIN CONTINUE Replace the standard prompts\n" - ".quit Exit this program\n" - ".read FILENAME Execute SQL in FILENAME\n" - ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n" - ".schema ?TABLE? Show the CREATE statements\n" - " If TABLE specified, only show tables matching\n" - " LIKE pattern TABLE.\n" - ".separator STRING Change separator used by output mode and .import\n" - ".show Show the current values for various settings\n" - ".tables ?TABLE? List names of tables\n" - " If TABLE specified, only list tables matching\n" - " LIKE pattern TABLE.\n" - ".timeout MS Try opening locked tables for MS milliseconds\n" - ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n" -; - -static char zTimerHelp[] = - ".timer ON|OFF Turn the CPU timer measurement on or off\n" -; - -/* Forward reference */ -static int process_input(struct callback_data *p, FILE *in); - -/* -** Make sure the database is open. If it is not, then open it. If -** the database fails to open, print an error message and exit. -*/ -static void open_db(struct callback_data *p){ - if( p->db==0 ){ - sqlite3_open(p->zDbFilename, &p->db); - db = p->db; - if( db && sqlite3_errcode(db)==SQLITE_OK ){ - sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0, - shellstaticFunc, 0, 0); - } - if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){ - fprintf(stderr,"Error: unable to open database \"%s\": %s\n", - p->zDbFilename, sqlite3_errmsg(db)); - exit(1); - } -#ifndef SQLITE_OMIT_LOAD_EXTENSION - sqlite3_enable_load_extension(p->db, 1); -#endif - } -} - -/* -** Do C-language style dequoting. -** -** \t -> tab -** \n -> newline -** \r -> carriage return -** \NNN -> ascii character NNN in octal -** \\ -> backslash -*/ -static void resolve_backslashes(char *z){ - int i, j; - char c; - for(i=j=0; (c = z[i])!=0; i++, j++){ - if( c=='\\' ){ - c = z[++i]; - if( c=='n' ){ - c = '\n'; - }else if( c=='t' ){ - c = '\t'; - }else if( c=='r' ){ - c = '\r'; - }else if( c>='0' && c<='7' ){ - c -= '0'; - if( z[i+1]>='0' && z[i+1]<='7' ){ - i++; - c = (c<<3) + z[i] - '0'; - if( z[i+1]>='0' && z[i+1]<='7' ){ - i++; - c = (c<<3) + z[i] - '0'; - } - } - } - } - z[j] = c; - } - z[j] = 0; -} - -/* -** Interpret zArg as a boolean value. Return either 0 or 1. -*/ -static int booleanValue(char *zArg){ - int val = atoi(zArg); - int j; - for(j=0; zArg[j]; j++){ - zArg[j] = (char)tolower(zArg[j]); - } - if( strcmp(zArg,"on")==0 ){ - val = 1; - }else if( strcmp(zArg,"yes")==0 ){ - val = 1; - } - return val; -} - -/* -** If an input line begins with "." then invoke this routine to -** process that line. -** -** Return 1 on error, 2 to exit, and 0 otherwise. -*/ -static int do_meta_command(char *zLine, struct callback_data *p){ - int i = 1; - int nArg = 0; - int n, c; - int rc = 0; - char *azArg[50]; - - /* Parse the input line into tokens. - */ - while( zLine[i] && nArg=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){ - const char *zDestFile; - const char *zDb; - sqlite3 *pDest; - sqlite3_backup *pBackup; - if( nArg==2 ){ - zDestFile = azArg[1]; - zDb = "main"; - }else{ - zDestFile = azArg[2]; - zDb = azArg[1]; - } - rc = sqlite3_open(zDestFile, &pDest); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile); - sqlite3_close(pDest); - return 1; - } - open_db(p); - pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); - if( pBackup==0 ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); - sqlite3_close(pDest); - return 1; - } - while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} - sqlite3_backup_finish(pBackup); - if( rc==SQLITE_DONE ){ - rc = 0; - }else{ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); - rc = 1; - } - sqlite3_close(pDest); - }else - - if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){ - bail_on_error = booleanValue(azArg[1]); - }else - - if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 1; - data.mode = MODE_Column; - data.colWidth[0] = 3; - data.colWidth[1] = 15; - data.colWidth[2] = 58; - data.cnt = 0; - sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - } - }else - - if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){ - char *zErrMsg = 0; - open_db(p); - /* When playing back a "dump", the content might appear in an order - ** which causes immediate foreign key constraints to be violated. - ** So disable foreign-key constraint enforcement to prevent problems. */ - fprintf(p->out, "PRAGMA foreign_keys=OFF;\n"); - fprintf(p->out, "BEGIN TRANSACTION;\n"); - p->writableSchema = 0; - sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0); - if( nArg==1 ){ - run_schema_dump_query(p, - "SELECT name, type, sql FROM sqlite_master " - "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'", 0 - ); - run_schema_dump_query(p, - "SELECT name, type, sql FROM sqlite_master " - "WHERE name=='sqlite_sequence'", 0 - ); - run_table_dump_query(p->out, p->db, - "SELECT sql FROM sqlite_master " - "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 - ); - }else{ - int i; - for(i=1; iout, p->db, - "SELECT sql FROM sqlite_master " - "WHERE sql NOT NULL" - " AND type IN ('index','trigger','view')" - " AND tbl_name LIKE shellstatic()", 0 - ); - zShellStatic = 0; - } - } - if( p->writableSchema ){ - fprintf(p->out, "PRAGMA writable_schema=OFF;\n"); - p->writableSchema = 0; - } - sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0); - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - }else{ - fprintf(p->out, "COMMIT;\n"); - } - }else - - if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){ - p->echoOn = booleanValue(azArg[1]); - }else - - if( c=='e' && strncmp(azArg[0], "exit", n)==0 && nArg==1 ){ - rc = 2; - }else - - if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){ - int val = nArg>=2 ? booleanValue(azArg[1]) : 1; - if(val == 1) { - if(!p->explainPrev.valid) { - p->explainPrev.valid = 1; - p->explainPrev.mode = p->mode; - p->explainPrev.showHeader = p->showHeader; - memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth)); - } - /* We could put this code under the !p->explainValid - ** condition so that it does not execute if we are already in - ** explain mode. However, always executing it allows us an easy - ** was to reset to explain mode in case the user previously - ** did an .explain followed by a .width, .mode or .header - ** command. - */ - p->mode = MODE_Explain; - p->showHeader = 1; - memset(p->colWidth,0,ArraySize(p->colWidth)); - p->colWidth[0] = 4; /* addr */ - p->colWidth[1] = 13; /* opcode */ - p->colWidth[2] = 4; /* P1 */ - p->colWidth[3] = 4; /* P2 */ - p->colWidth[4] = 4; /* P3 */ - p->colWidth[5] = 13; /* P4 */ - p->colWidth[6] = 2; /* P5 */ - p->colWidth[7] = 13; /* Comment */ - }else if (p->explainPrev.valid) { - p->explainPrev.valid = 0; - p->mode = p->explainPrev.mode; - p->showHeader = p->explainPrev.showHeader; - memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth)); - } - }else - - if( c=='h' && (strncmp(azArg[0], "header", n)==0 || - strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){ - p->showHeader = booleanValue(azArg[1]); - }else - - if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ - fprintf(stderr,"%s",zHelp); - if( HAS_TIMER ){ - fprintf(stderr,"%s",zTimerHelp); - } - }else - - if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){ - char *zTable = azArg[2]; /* Insert data into this table */ - char *zFile = azArg[1]; /* The file from which to extract data */ - sqlite3_stmt *pStmt = NULL; /* A statement */ - int nCol; /* Number of columns in the table */ - int nByte; /* Number of bytes in an SQL string */ - int i, j; /* Loop counters */ - int nSep; /* Number of bytes in p->separator[] */ - char *zSql; /* An SQL statement */ - char *zLine; /* A single line of input from the file */ - char **azCol; /* zLine[] broken up into columns */ - char *zCommit; /* How to commit changes */ - FILE *in; /* The input file */ - int lineno = 0; /* Line number of input file */ - - open_db(p); - nSep = strlen30(p->separator); - if( nSep==0 ){ - fprintf(stderr, "Error: non-null separator required for import\n"); - return 1; - } - zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - return 1; - } - nByte = strlen30(zSql); - rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); - sqlite3_free(zSql); - if( rc ){ - if (pStmt) sqlite3_finalize(pStmt); - fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db)); - return 1; - } - nCol = sqlite3_column_count(pStmt); - sqlite3_finalize(pStmt); - pStmt = 0; - if( nCol==0 ) return 0; /* no columns, no error */ - zSql = malloc( nByte + 20 + nCol*2 ); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - return 1; - } - sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable); - j = strlen30(zSql); - for(i=1; idb, zSql, -1, &pStmt, 0); - free(zSql); - if( rc ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db)); - if (pStmt) sqlite3_finalize(pStmt); - return 1; - } - in = fopen(zFile, "rb"); - if( in==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); - sqlite3_finalize(pStmt); - return 1; - } - azCol = malloc( sizeof(azCol[0])*(nCol+1) ); - if( azCol==0 ){ - fprintf(stderr, "Error: out of memory\n"); - fclose(in); - sqlite3_finalize(pStmt); - return 1; - } - sqlite3_exec(p->db, "BEGIN", 0, 0, 0); - zCommit = "COMMIT"; - while( (zLine = local_getline(0, in))!=0 ){ - char *z; - i = 0; - lineno++; - azCol[0] = zLine; - for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){ - if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){ - *z = 0; - i++; - if( idb, zCommit, 0, 0, 0); - }else - - if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 0; - data.mode = MODE_List; - if( nArg==1 ){ - rc = sqlite3_exec(p->db, - "SELECT name FROM sqlite_master " - "WHERE type='index' AND name NOT LIKE 'sqlite_%' " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type='index' " - "ORDER BY 1", - callback, &data, &zErrMsg - ); - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_exec(p->db, - "SELECT name FROM sqlite_master " - "WHERE type='index' AND tbl_name LIKE shellstatic() " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type='index' AND tbl_name LIKE shellstatic() " - "ORDER BY 1", - callback, &data, &zErrMsg - ); - zShellStatic = 0; - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); - rc = 1; - } - }else - -#ifdef SQLITE_ENABLE_IOTRACE - if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ - extern void (*sqlite3IoTrace)(const char*, ...); - if( iotrace && iotrace!=stdout ) fclose(iotrace); - iotrace = 0; - if( nArg<2 ){ - sqlite3IoTrace = 0; - }else if( strcmp(azArg[1], "-")==0 ){ - sqlite3IoTrace = iotracePrintf; - iotrace = stdout; - }else{ - iotrace = fopen(azArg[1], "w"); - if( iotrace==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); - sqlite3IoTrace = 0; - rc = 1; - }else{ - sqlite3IoTrace = iotracePrintf; - } - } - }else -#endif - -#ifndef SQLITE_OMIT_LOAD_EXTENSION - if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){ - const char *zFile, *zProc; - char *zErrMsg = 0; - zFile = azArg[1]; - zProc = nArg>=3 ? azArg[2] : 0; - open_db(p); - rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - } - }else -#endif - - if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=1 ){ - const char *zFile = azArg[1]; - if( p->pLog && p->pLog!=stdout && p->pLog!=stderr ){ - fclose(p->pLog); - p->pLog = 0; - } - if( strcmp(zFile,"stdout")==0 ){ - p->pLog = stdout; - }else if( strcmp(zFile, "stderr")==0 ){ - p->pLog = stderr; - }else if( strcmp(zFile, "off")==0 ){ - p->pLog = 0; - }else{ - p->pLog = fopen(zFile, "w"); - if( p->pLog==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); - } - } - }else - - if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){ - int n2 = strlen30(azArg[1]); - if( (n2==4 && strncmp(azArg[1],"line",n2)==0) - || - (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){ - p->mode = MODE_Line; - }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0) - || - (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){ - p->mode = MODE_Column; - }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){ - p->mode = MODE_List; - }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){ - p->mode = MODE_Html; - }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){ - p->mode = MODE_Tcl; - }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){ - p->mode = MODE_Csv; - sqlite3_snprintf(sizeof(p->separator), p->separator, ","); - }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){ - p->mode = MODE_List; - sqlite3_snprintf(sizeof(p->separator), p->separator, "\t"); - }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){ - p->mode = MODE_Insert; - set_table_name(p, "table"); - }else { - fprintf(stderr,"Error: mode should be one of: " - "column csv html insert line list tabs tcl\n"); - rc = 1; - } - }else - - if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){ - int n2 = strlen30(azArg[1]); - if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){ - p->mode = MODE_Insert; - set_table_name(p, azArg[2]); - }else { - fprintf(stderr, "Error: invalid arguments: " - " \"%s\". Enter \".help\" for help\n", azArg[2]); - rc = 1; - } - }else - - if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) { - sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue, - "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]); - }else - - if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){ - if( p->out!=stdout ){ - fclose(p->out); - } - if( strcmp(azArg[1],"stdout")==0 ){ - p->out = stdout; - sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout"); - }else{ - p->out = fopen(azArg[1], "wb"); - if( p->out==0 ){ - fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]); - p->out = stdout; - rc = 1; - } else { - sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]); - } - } - }else - - if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){ - if( nArg >= 2) { - strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); - } - if( nArg >= 3) { - strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); - } - }else - - if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){ - rc = 2; - }else - - if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){ - FILE *alt = fopen(azArg[1], "rb"); - if( alt==0 ){ - fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); - rc = 1; - }else{ - rc = process_input(p, alt); - fclose(alt); - } - }else - - if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){ - const char *zSrcFile; - const char *zDb; - sqlite3 *pSrc; - sqlite3_backup *pBackup; - int nTimeout = 0; - - if( nArg==2 ){ - zSrcFile = azArg[1]; - zDb = "main"; - }else{ - zSrcFile = azArg[2]; - zDb = azArg[1]; - } - rc = sqlite3_open(zSrcFile, &pSrc); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); - sqlite3_close(pSrc); - return 1; - } - open_db(p); - pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); - if( pBackup==0 ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); - sqlite3_close(pSrc); - return 1; - } - while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK - || rc==SQLITE_BUSY ){ - if( rc==SQLITE_BUSY ){ - if( nTimeout++ >= 3 ) break; - sqlite3_sleep(100); - } - } - sqlite3_backup_finish(pBackup); - if( rc==SQLITE_DONE ){ - rc = 0; - }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ - fprintf(stderr, "Error: source database is busy\n"); - rc = 1; - }else{ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); - rc = 1; - } - sqlite3_close(pSrc); - }else - - if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 0; - data.mode = MODE_Semi; - if( nArg>1 ){ - int i; - for(i=0; azArg[1][i]; i++) azArg[1][i] = (char)tolower(azArg[1][i]); - if( strcmp(azArg[1],"sqlite_master")==0 ){ - char *new_argv[2], *new_colv[2]; - new_argv[0] = "CREATE TABLE sqlite_master (\n" - " type text,\n" - " name text,\n" - " tbl_name text,\n" - " rootpage integer,\n" - " sql text\n" - ")"; - new_argv[1] = 0; - new_colv[0] = "sql"; - new_colv[1] = 0; - callback(&data, 1, new_argv, new_colv); - rc = SQLITE_OK; - }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){ - char *new_argv[2], *new_colv[2]; - new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" - " type text,\n" - " name text,\n" - " tbl_name text,\n" - " rootpage integer,\n" - " sql text\n" - ")"; - new_argv[1] = 0; - new_colv[0] = "sql"; - new_colv[1] = 0; - callback(&data, 1, new_argv, new_colv); - rc = SQLITE_OK; - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_exec(p->db, - "SELECT sql FROM " - " (SELECT sql sql, type type, tbl_name tbl_name, name name" - " FROM sqlite_master UNION ALL" - " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) " - "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL " - "ORDER BY substr(type,2,1), name", - callback, &data, &zErrMsg); - zShellStatic = 0; - } - }else{ - rc = sqlite3_exec(p->db, - "SELECT sql FROM " - " (SELECT sql sql, type type, tbl_name tbl_name, name name" - " FROM sqlite_master UNION ALL" - " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) " - "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'" - "ORDER BY substr(type,2,1), name", - callback, &data, &zErrMsg - ); - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying schema information\n"); - rc = 1; - }else{ - rc = 0; - } - }else - - if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){ - sqlite3_snprintf(sizeof(p->separator), p->separator, - "%.*s", (int)sizeof(p->separator)-1, azArg[1]); - }else - - if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){ - int i; - fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off"); - fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off"); - fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off"); - fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]); - fprintf(p->out,"%9.9s: ", "nullvalue"); - output_c_string(p->out, p->nullvalue); - fprintf(p->out, "\n"); - fprintf(p->out,"%9.9s: %s\n","output", - strlen30(p->outfile) ? p->outfile : "stdout"); - fprintf(p->out,"%9.9s: ", "separator"); - output_c_string(p->out, p->separator); - fprintf(p->out, "\n"); - fprintf(p->out,"%9.9s: ","width"); - for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { - fprintf(p->out,"%d ",p->colWidth[i]); - } - fprintf(p->out,"\n"); - }else - - if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){ - char **azResult; - int nRow; - char *zErrMsg; - open_db(p); - if( nArg==1 ){ - rc = sqlite3_get_table(p->db, - "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type IN ('table','view') " - "ORDER BY 1", - &azResult, &nRow, 0, &zErrMsg - ); - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_get_table(p->db, - "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') AND name LIKE shellstatic() " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type IN ('table','view') AND name LIKE shellstatic() " - "ORDER BY 1", - &azResult, &nRow, 0, &zErrMsg - ); - zShellStatic = 0; - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); - rc = 1; - }else{ - int len, maxlen = 0; - int i, j; - int nPrintCol, nPrintRow; - for(i=1; i<=nRow; i++){ - if( azResult[i]==0 ) continue; - len = strlen30(azResult[i]); - if( len>maxlen ) maxlen = len; - } - nPrintCol = 80/(maxlen+2); - if( nPrintCol<1 ) nPrintCol = 1; - nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; - for(i=0; i4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){ - open_db(p); - sqlite3_busy_timeout(p->db, atoi(azArg[1])); - }else - - if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg==2 ){ - enableTimer = booleanValue(azArg[1]); - }else - - if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){ - int j; - assert( nArg<=ArraySize(azArg) ); - for(j=1; jcolWidth); j++){ - p->colWidth[j-1] = atoi(azArg[j]); - } - }else - - { - fprintf(stderr, "Error: unknown command or invalid arguments: " - " \"%s\". Enter \".help\" for help\n", azArg[0]); - rc = 1; - } - - return rc; -} - -/* -** Return TRUE if a semicolon occurs anywhere in the first N characters -** of string z[]. -*/ -static int _contains_semicolon(const char *z, int N){ - int i; - for(i=0; iout); - free(zLine); - zLine = one_input_line(zSql, in); - if( zLine==0 ){ - break; /* We have reached EOF */ - } - if( seenInterrupt ){ - if( in!=0 ) break; - seenInterrupt = 0; - } - lineno++; - if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue; - if( zLine && zLine[0]=='.' && nSql==0 ){ - if( p->echoOn ) printf("%s\n", zLine); - rc = do_meta_command(zLine, p); - if( rc==2 ){ /* exit requested */ - break; - }else if( rc ){ - errCnt++; - } - continue; - } - if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){ - memcpy(zLine,";",2); - } - nSqlPrior = nSql; - if( zSql==0 ){ - int i; - for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){} - if( zLine[i]!=0 ){ - nSql = strlen30(zLine); - zSql = malloc( nSql+3 ); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - exit(1); - } - memcpy(zSql, zLine, nSql+1); - startline = lineno; - } - }else{ - int len = strlen30(zLine); - zSql = realloc( zSql, nSql + len + 4 ); - if( zSql==0 ){ - fprintf(stderr,"Error: out of memory\n"); - exit(1); - } - zSql[nSql++] = '\n'; - memcpy(&zSql[nSql], zLine, len+1); - nSql += len; - } - if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) - && sqlite3_complete(zSql) ){ - p->cnt = 0; - open_db(p); - BEGIN_TIMER; - rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg); - END_TIMER; - if( rc || zErrMsg ){ - char zPrefix[100]; - if( in!=0 || !stdin_is_interactive ){ - sqlite3_snprintf(sizeof(zPrefix), zPrefix, - "Error: near line %d:", startline); - }else{ - sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); - } - if( zErrMsg!=0 ){ - fprintf(stderr, "%s %s\n", zPrefix, zErrMsg); - sqlite3_free(zErrMsg); - zErrMsg = 0; - }else{ - fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); - } - errCnt++; - } - free(zSql); - zSql = 0; - nSql = 0; - } - } - if( zSql ){ - if( !_all_whitespace(zSql) ) fprintf(stderr, "Error: incomplete SQL: %s\n", zSql); - free(zSql); - } - free(zLine); - return errCnt; -} - -/* -** Return a pathname which is the user's home directory. A -** 0 return indicates an error of some kind. Space to hold the -** resulting string is obtained from malloc(). The calling -** function should free the result. -*/ -static char *find_home_dir(void){ - char *home_dir = NULL; - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL) - struct passwd *pwent; - uid_t uid = getuid(); - if( (pwent=getpwuid(uid)) != NULL) { - home_dir = pwent->pw_dir; - } -#endif - -#if defined(_WIN32_WCE) - /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() - */ - home_dir = strdup("/"); -#else - -#if defined(_WIN32) || defined(WIN32) || defined(__OS2__) - if (!home_dir) { - home_dir = getenv("USERPROFILE"); - } -#endif - - if (!home_dir) { - home_dir = getenv("HOME"); - } - -#if defined(_WIN32) || defined(WIN32) || defined(__OS2__) - if (!home_dir) { - char *zDrive, *zPath; - int n; - zDrive = getenv("HOMEDRIVE"); - zPath = getenv("HOMEPATH"); - if( zDrive && zPath ){ - n = strlen30(zDrive) + strlen30(zPath) + 1; - home_dir = malloc( n ); - if( home_dir==0 ) return 0; - sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); - return home_dir; - } - home_dir = "c:\\"; - } -#endif - -#endif /* !_WIN32_WCE */ - - if( home_dir ){ - int n = strlen30(home_dir) + 1; - char *z = malloc( n ); - if( z ) memcpy(z, home_dir, n); - home_dir = z; - } - - return home_dir; -} - -/* -** Read input from the file given by sqliterc_override. Or if that -** parameter is NULL, take input from ~/.sqliterc -** -** Returns the number of errors. -*/ -static int process_sqliterc( - struct callback_data *p, /* Configuration data */ - const char *sqliterc_override /* Name of config file. NULL to use default */ -){ - char *home_dir = NULL; - const char *sqliterc = sqliterc_override; - char *zBuf = 0; - FILE *in = NULL; - int nBuf; - int rc = 0; - - if (sqliterc == NULL) { - home_dir = find_home_dir(); - if( home_dir==0 ){ -#if !defined(__RTP__) && !defined(_WRS_KERNEL) - fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0); -#endif - return 1; - } - nBuf = strlen30(home_dir) + 16; - zBuf = malloc( nBuf ); - if( zBuf==0 ){ - fprintf(stderr,"%s: Error: out of memory\n",Argv0); - return 1; - } - sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir); - free(home_dir); - sqliterc = (const char*)zBuf; - } - in = fopen(sqliterc,"rb"); - if( in ){ - if( stdin_is_interactive ){ - fprintf(stderr,"-- Loading resources from %s\n",sqliterc); - } - rc = process_input(p,in); - fclose(in); - } - free(zBuf); - return rc; -} - -/* -** Show available command line options -*/ -static const char zOptions[] = - " -help show this message\n" - " -init filename read/process named file\n" - " -echo print commands before execution\n" - " -[no]header turn headers on or off\n" - " -bail stop after hitting an error\n" - " -interactive force interactive I/O\n" - " -batch force batch I/O\n" - " -column set output mode to 'column'\n" - " -csv set output mode to 'csv'\n" - " -html set output mode to HTML\n" - " -line set output mode to 'line'\n" - " -list set output mode to 'list'\n" - " -separator 'x' set output field separator (|)\n" - " -nullvalue 'text' set text string for NULL values\n" - " -version show SQLite version\n" -; -static void usage(int showDetail){ - fprintf(stderr, - "Usage: %s [OPTIONS] FILENAME [SQL]\n" - "FILENAME is the name of an SQLite database. A new database is created\n" - "if the file does not previously exist.\n", Argv0); - if( showDetail ){ - fprintf(stderr, "OPTIONS include:\n%s", zOptions); - }else{ - fprintf(stderr, "Use the -help option for additional information\n"); - } - exit(1); -} - -/* -** Initialize the state information in data -*/ -static void main_init(struct callback_data *data) { - memset(data, 0, sizeof(*data)); - data->mode = MODE_List; - memcpy(data->separator,"|", 2); - data->showHeader = 0; - sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); - sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); - sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); - sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); -} - -int main(int argc, char **argv){ - char *zErrMsg = 0; - struct callback_data data; - const char *zInitFile = 0; - char *zFirstCmd = 0; - int i; - int rc = 0; - - Argv0 = argv[0]; - main_init(&data); - stdin_is_interactive = isatty(0); - - /* Make sure we have a valid signal handler early, before anything - ** else is done. - */ -#ifdef SIGINT - signal(SIGINT, interrupt_handler); -#endif - - /* Do an initial pass through the command-line argument to locate - ** the name of the database file, the name of the initialization file, - ** and the first command to execute. - */ - for(i=1; i0 ){ - return rc; - } - - /* Make a second pass through the command-line argument and set - ** options. This second pass is delayed until after the initialization - ** file is processed so that the command-line arguments will override - ** settings in the initialization file. - */ - for(i=1; i=argc){ - fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - sqlite3_snprintf(sizeof(data.separator), data.separator, - "%.*s",(int)sizeof(data.separator)-1,argv[i]); - }else if( strcmp(z,"-nullvalue")==0 ){ - i++; - if(i>=argc){ - fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue, - "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]); - }else if( strcmp(z,"-header")==0 ){ - data.showHeader = 1; - }else if( strcmp(z,"-noheader")==0 ){ - data.showHeader = 0; - }else if( strcmp(z,"-echo")==0 ){ - data.echoOn = 1; - }else if( strcmp(z,"-bail")==0 ){ - bail_on_error = 1; - }else if( strcmp(z,"-version")==0 ){ - printf("%s\n", sqlite3_libversion()); - return 0; - }else if( strcmp(z,"-interactive")==0 ){ - stdin_is_interactive = 1; - }else if( strcmp(z,"-batch")==0 ){ - stdin_is_interactive = 0; - }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){ - usage(1); - }else{ - fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - } - - if( zFirstCmd ){ - /* Run just the command that follows the database name - */ - if( zFirstCmd[0]=='.' ){ - rc = do_meta_command(zFirstCmd, &data); - return rc; - }else{ - open_db(&data); - rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg); - if( zErrMsg!=0 ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - return rc!=0 ? rc : 1; - }else if( rc!=0 ){ - fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd); - return rc; - } - } - }else{ - /* Run commands received from standard input - */ - if( stdin_is_interactive ){ - char *zHome; - char *zHistory = 0; - int nHistory; - printf( - "SQLite version %s\n" - "Enter \".help\" for instructions\n" - "Enter SQL statements terminated with a \";\"\n", - sqlite3_libversion() - ); - zHome = find_home_dir(); - if( zHome ){ - nHistory = strlen30(zHome) + 20; - if( (zHistory = malloc(nHistory))!=0 ){ - sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); - } - } -#if defined(HAVE_READLINE) && HAVE_READLINE==1 - if( zHistory ) read_history(zHistory); -#endif - rc = process_input(&data, 0); - if( zHistory ){ - stifle_history(100); - write_history(zHistory); - free(zHistory); - } - free(zHome); - }else{ - rc = process_input(&data, stdin); - } - } - set_table_name(&data, 0); - if( db ){ - if( sqlite3_close(db)!=SQLITE_OK ){ - fprintf(stderr,"Error: cannot close database \"%s\"\n", sqlite3_errmsg(db)); - rc++; - } - } - return rc; -} diff --git a/win64/sqlite/sqlite3.c b/win64/sqlite/sqlite3.c deleted file mode 100644 index 4db4846..0000000 --- a/win64/sqlite/sqlite3.c +++ /dev/null @@ -1,112444 +0,0 @@ -/****************************************************************************** -** This file is an amalgamation of many separate C source files from SQLite -** version 3.6.23.1. By combining all the individual C code files into this -** single large file, the entire code can be compiled as a one translation -** unit. This allows many compilers to do optimizations that would not be -** possible if the files were compiled separately. Performance improvements -** of 5% are more are commonly seen when SQLite is compiled as a single -** translation unit. -** -** This file is all you need to compile SQLite. To use SQLite in other -** programs, you need this file and the "sqlite3.h" header file that defines -** the programming interface to the SQLite library. (If you do not have -** the "sqlite3.h" header file at hand, you will find a copy embedded within -** the text of this file. Search for "Begin file sqlite3.h" to find the start -** of the embedded sqlite3.h header file.) Additional code files may be needed -** if you want a wrapper to interface SQLite with your choice of programming -** language. The code for the "sqlite3" command-line shell is also in a -** separate file. This file contains only code for the core SQLite library. -*/ -#define SQLITE_CORE 1 -#define SQLITE_AMALGAMATION 1 -#ifndef SQLITE_PRIVATE -# define SQLITE_PRIVATE static -#endif -#ifndef SQLITE_API -# define SQLITE_API -#endif -/************** Begin file sqliteInt.h ***************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** Internal interface definitions for SQLite. -** -*/ -#ifndef _SQLITEINT_H_ -#define _SQLITEINT_H_ - -/* -** These #defines should enable >2GB file support on POSIX if the -** underlying operating system supports it. If the OS lacks -** large file support, or if the OS is windows, these should be no-ops. -** -** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any -** system #includes. Hence, this block of code must be the very first -** code in all source files. -** -** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch -** on the compiler command line. This is necessary if you are compiling -** on a recent machine (ex: Red Hat 7.2) but you want your code to work -** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 -** without this option, LFS is enable. But LFS does not exist in the kernel -** in Red Hat 6.0, so the code won't work. Hence, for maximum binary -** portability you should omit LFS. -** -** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. -*/ -#ifndef SQLITE_DISABLE_LFS -# define _LARGE_FILE 1 -# ifndef _FILE_OFFSET_BITS -# define _FILE_OFFSET_BITS 64 -# endif -# define _LARGEFILE_SOURCE 1 -#endif - -/* -** Include the configuration header output by 'configure' if we're using the -** autoconf-based build -*/ -#ifdef _HAVE_SQLITE_CONFIG_H -#include "config.h" -#endif - -/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ -/************** Begin file sqliteLimit.h *************************************/ -/* -** 2007 May 7 -** -** 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 file defines various limits of what SQLite can process. -*/ - -/* -** The maximum length of a TEXT or BLOB in bytes. This also -** limits the size of a row in a table or index. -** -** The hard limit is the ability of a 32-bit signed integer -** to count the size: 2^31-1 or 2147483647. -*/ -#ifndef SQLITE_MAX_LENGTH -# define SQLITE_MAX_LENGTH 1000000000 -#endif - -/* -** This is the maximum number of -** -** * Columns in a table -** * Columns in an index -** * Columns in a view -** * Terms in the SET clause of an UPDATE statement -** * Terms in the result set of a SELECT statement -** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. -** * Terms in the VALUES clause of an INSERT statement -** -** The hard upper limit here is 32676. Most database people will -** tell you that in a well-normalized database, you usually should -** not have more than a dozen or so columns in any table. And if -** that is the case, there is no point in having more than a few -** dozen values in any of the other situations described above. -*/ -#ifndef SQLITE_MAX_COLUMN -# define SQLITE_MAX_COLUMN 2000 -#endif - -/* -** The maximum length of a single SQL statement in bytes. -** -** It used to be the case that setting this value to zero would -** turn the limit off. That is no longer true. It is not possible -** to turn this limit off. -*/ -#ifndef SQLITE_MAX_SQL_LENGTH -# define SQLITE_MAX_SQL_LENGTH 1000000000 -#endif - -/* -** The maximum depth of an expression tree. This is limited to -** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might -** want to place more severe limits on the complexity of an -** expression. -** -** A value of 0 used to mean that the limit was not enforced. -** But that is no longer true. The limit is now strictly enforced -** at all times. -*/ -#ifndef SQLITE_MAX_EXPR_DEPTH -# define SQLITE_MAX_EXPR_DEPTH 1000 -#endif - -/* -** The maximum number of terms in a compound SELECT statement. -** The code generator for compound SELECT statements does one -** level of recursion for each term. A stack overflow can result -** if the number of terms is too large. In practice, most SQL -** never has more than 3 or 4 terms. Use a value of 0 to disable -** any limit on the number of terms in a compount SELECT. -*/ -#ifndef SQLITE_MAX_COMPOUND_SELECT -# define SQLITE_MAX_COMPOUND_SELECT 500 -#endif - -/* -** The maximum number of opcodes in a VDBE program. -** Not currently enforced. -*/ -#ifndef SQLITE_MAX_VDBE_OP -# define SQLITE_MAX_VDBE_OP 25000 -#endif - -/* -** The maximum number of arguments to an SQL function. -*/ -#ifndef SQLITE_MAX_FUNCTION_ARG -# define SQLITE_MAX_FUNCTION_ARG 127 -#endif - -/* -** The maximum number of in-memory pages to use for the main database -** table and for temporary tables. The SQLITE_DEFAULT_CACHE_SIZE -*/ -#ifndef SQLITE_DEFAULT_CACHE_SIZE -# define SQLITE_DEFAULT_CACHE_SIZE 2000 -#endif -#ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE -# define SQLITE_DEFAULT_TEMP_CACHE_SIZE 500 -#endif - -/* -** The maximum number of attached databases. This must be between 0 -** and 30. The upper bound on 30 is because a 32-bit integer bitmap -** is used internally to track attached databases. -*/ -#ifndef SQLITE_MAX_ATTACHED -# define SQLITE_MAX_ATTACHED 10 -#endif - - -/* -** The maximum value of a ?nnn wildcard that the parser will accept. -*/ -#ifndef SQLITE_MAX_VARIABLE_NUMBER -# define SQLITE_MAX_VARIABLE_NUMBER 999 -#endif - -/* Maximum page size. The upper bound on this value is 32768. This a limit -** imposed by the necessity of storing the value in a 2-byte unsigned integer -** and the fact that the page size must be a power of 2. -** -** If this limit is changed, then the compiled library is technically -** incompatible with an SQLite library compiled with a different limit. If -** a process operating on a database with a page-size of 65536 bytes -** crashes, then an instance of SQLite compiled with the default page-size -** limit will not be able to rollback the aborted transaction. This could -** lead to database corruption. -*/ -#ifndef SQLITE_MAX_PAGE_SIZE -# define SQLITE_MAX_PAGE_SIZE 32768 -#endif - - -/* -** The default size of a database page. -*/ -#ifndef SQLITE_DEFAULT_PAGE_SIZE -# define SQLITE_DEFAULT_PAGE_SIZE 1024 -#endif -#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE -# undef SQLITE_DEFAULT_PAGE_SIZE -# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE -#endif - -/* -** Ordinarily, if no value is explicitly provided, SQLite creates databases -** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain -** device characteristics (sector-size and atomic write() support), -** SQLite may choose a larger value. This constant is the maximum value -** SQLite will choose on its own. -*/ -#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE -# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 -#endif -#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE -# undef SQLITE_MAX_DEFAULT_PAGE_SIZE -# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE -#endif - - -/* -** Maximum number of pages in one database file. -** -** This is really just the default value for the max_page_count pragma. -** This value can be lowered (or raised) at run-time using that the -** max_page_count macro. -*/ -#ifndef SQLITE_MAX_PAGE_COUNT -# define SQLITE_MAX_PAGE_COUNT 1073741823 -#endif - -/* -** Maximum length (in bytes) of the pattern in a LIKE or GLOB -** operator. -*/ -#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH -# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 -#endif - -/* -** Maximum depth of recursion for triggers. -** -** A value of 1 means that a trigger program will not be able to itself -** fire any triggers. A value of 0 means that no trigger programs at all -** may be executed. -*/ -#ifndef SQLITE_MAX_TRIGGER_DEPTH -# define SQLITE_MAX_TRIGGER_DEPTH 1000 -#endif - -/************** End of sqliteLimit.h *****************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - -/* Disable nuisance warnings on Borland compilers */ -#if defined(__BORLANDC__) -#pragma warn -rch /* unreachable code */ -#pragma warn -ccc /* Condition is always true or false */ -#pragma warn -aus /* Assigned value is never used */ -#pragma warn -csu /* Comparing signed and unsigned */ -#pragma warn -spa /* Suspicious pointer arithmetic */ -#endif - -/* Needed for various definitions... */ -#ifndef _GNU_SOURCE -# define _GNU_SOURCE -#endif - -/* -** Include standard header files as necessary -*/ -#ifdef HAVE_STDINT_H -#include -#endif -#ifdef HAVE_INTTYPES_H -#include -#endif - -/* -** The number of samples of an index that SQLite takes in order to -** construct a histogram of the table content when running ANALYZE -** and with SQLITE_ENABLE_STAT2 -*/ -#define SQLITE_INDEX_SAMPLES 10 - -/* -** The following macros are used to cast pointers to integers and -** integers to pointers. The way you do this varies from one compiler -** to the next, so we have developed the following set of #if statements -** to generate appropriate macros for a wide range of compilers. -** -** The correct "ANSI" way to do this is to use the intptr_t type. -** Unfortunately, that typedef is not available on all compilers, or -** if it is available, it requires an #include of specific headers -** that very from one machine to the next. -** -** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on -** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). -** So we have to define the macros in different ways depending on the -** compiler. -*/ -#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ -# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) -#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ -# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) -# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) -#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ -# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) -#else /* Generates a warning - but it always works */ -# define SQLITE_INT_TO_PTR(X) ((void*)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(X)) -#endif - -/* -** The SQLITE_THREADSAFE macro must be defined as either 0 or 1. -** Older versions of SQLite used an optional THREADSAFE macro. -** We support that for legacy -*/ -#if !defined(SQLITE_THREADSAFE) -#if defined(THREADSAFE) -# define SQLITE_THREADSAFE THREADSAFE -#else -# define SQLITE_THREADSAFE 1 -#endif -#endif - -/* -** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1. -** It determines whether or not the features related to -** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can -** be overridden at runtime using the sqlite3_config() API. -*/ -#if !defined(SQLITE_DEFAULT_MEMSTATUS) -# define SQLITE_DEFAULT_MEMSTATUS 1 -#endif - -/* -** Exactly one of the following macros must be defined in order to -** specify which memory allocation subsystem to use. -** -** SQLITE_SYSTEM_MALLOC // Use normal system malloc() -** SQLITE_MEMDEBUG // Debugging version of system malloc() -** -** (Historical note: There used to be several other options, but we've -** pared it down to just these two.) -** -** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as -** the default. -*/ -#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)>1 -# error "At most one of the following compile-time configuration options\ - is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG" -#endif -#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)==0 -# define SQLITE_SYSTEM_MALLOC 1 -#endif - -/* -** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the -** sizes of memory allocations below this value where possible. -*/ -#if !defined(SQLITE_MALLOC_SOFT_LIMIT) -# define SQLITE_MALLOC_SOFT_LIMIT 1024 -#endif - -/* -** We need to define _XOPEN_SOURCE as follows in order to enable -** recursive mutexes on most Unix systems. But Mac OS X is different. -** The _XOPEN_SOURCE define causes problems for Mac OS X we are told, -** so it is omitted there. See ticket #2673. -** -** Later we learn that _XOPEN_SOURCE is poorly or incorrectly -** implemented on some systems. So we avoid defining it at all -** if it is already defined or if it is unneeded because we are -** not doing a threadsafe build. Ticket #2681. -** -** See also ticket #2741. -*/ -#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE -# define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */ -#endif - -/* -** The TCL headers are only needed when compiling the TCL bindings. -*/ -#if defined(SQLITE_TCL) || defined(TCLSH) -# include -#endif - -/* -** Many people are failing to set -DNDEBUG=1 when compiling SQLite. -** Setting NDEBUG makes the code smaller and run faster. So the following -** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1 -** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out -** feature. -*/ -#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) -# define NDEBUG 1 -#endif - -/* -** The testcase() macro is used to aid in coverage testing. When -** doing coverage testing, the condition inside the argument to -** testcase() must be evaluated both true and false in order to -** get full branch coverage. The testcase() macro is inserted -** to help ensure adequate test coverage in places where simple -** condition/decision coverage is inadequate. For example, testcase() -** can be used to make sure boundary values are tested. For -** bitmask tests, testcase() can be used to make sure each bit -** is significant and used at least once. On switch statements -** where multiple cases go to the same block of code, testcase() -** can insure that all cases are evaluated. -** -*/ -#ifdef SQLITE_COVERAGE_TEST -SQLITE_PRIVATE void sqlite3Coverage(int); -# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } -#else -# define testcase(X) -#endif - -/* -** The TESTONLY macro is used to enclose variable declarations or -** other bits of code that are needed to support the arguments -** within testcase() and assert() macros. -*/ -#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) -# define TESTONLY(X) X -#else -# define TESTONLY(X) -#endif - -/* -** Sometimes we need a small amount of code such as a variable initialization -** to setup for a later assert() statement. We do not want this code to -** appear when assert() is disabled. The following macro is therefore -** used to contain that setup code. The "VVA" acronym stands for -** "Verification, Validation, and Accreditation". In other words, the -** code within VVA_ONLY() will only run during verification processes. -*/ -#ifndef NDEBUG -# define VVA_ONLY(X) X -#else -# define VVA_ONLY(X) -#endif - -/* -** The ALWAYS and NEVER macros surround boolean expressions which -** are intended to always be true or false, respectively. Such -** expressions could be omitted from the code completely. But they -** are included in a few cases in order to enhance the resilience -** of SQLite to unexpected behavior - to make the code "self-healing" -** or "ductile" rather than being "brittle" and crashing at the first -** hint of unplanned behavior. -** -** In other words, ALWAYS and NEVER are added for defensive code. -** -** When doing coverage testing ALWAYS and NEVER are hard-coded to -** be true and false so that the unreachable code then specify will -** not be counted as untested code. -*/ -#if defined(SQLITE_COVERAGE_TEST) -# define ALWAYS(X) (1) -# define NEVER(X) (0) -#elif !defined(NDEBUG) -# define ALWAYS(X) ((X)?1:(assert(0),0)) -# define NEVER(X) ((X)?(assert(0),1):0) -#else -# define ALWAYS(X) (X) -# define NEVER(X) (X) -#endif - -/* -** The macro unlikely() is a hint that surrounds a boolean -** expression that is usually false. Macro likely() surrounds -** a boolean expression that is usually true. GCC is able to -** use these hints to generate better code, sometimes. -*/ -#if defined(__GNUC__) && 0 -# define likely(X) __builtin_expect((X),1) -# define unlikely(X) __builtin_expect((X),0) -#else -# define likely(X) !!(X) -# define unlikely(X) !!(X) -#endif - -/************** Include sqlite3.h in the middle of sqliteInt.h ***************/ -/************** Begin file sqlite3.h *****************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the SQLite library -** presents to client programs. If a C-function, structure, datatype, -** or constant definition does not appear in this file, then it is -** not a published API of SQLite, is subject to change without -** notice, and should not be referenced by programs that use SQLite. -** -** Some of the definitions that are in this file are marked as -** "experimental". Experimental interfaces are normally new -** features recently added to SQLite. We do not anticipate changes -** to experimental interfaces but reserve the right to make minor changes -** if experience from use "in the wild" suggest such changes are prudent. -** -** The official C-language API documentation for SQLite is derived -** from comments in this file. This file is the authoritative source -** on how SQLite interfaces are suppose to operate. -** -** The name of this file under configuration management is "sqlite.h.in". -** The makefile makes some minor changes to this file (such as inserting -** the version number) and changes its name to "sqlite3.h" as -** part of the build process. -*/ -#ifndef _SQLITE3_H_ -#define _SQLITE3_H_ -#include /* Needed for the definition of va_list */ - -/* -** Make sure we can call this stuff from C++. -*/ -#if 0 -extern "C" { -#endif - - -/* -** Add the ability to override 'extern' -*/ -#ifndef SQLITE_EXTERN -# define SQLITE_EXTERN extern -#endif - -#ifndef SQLITE_API -# define SQLITE_API -#endif - - -/* -** These no-op macros are used in front of interfaces to mark those -** interfaces as either deprecated or experimental. New applications -** should not use deprecated interfaces - they are support for backwards -** compatibility only. Application writers should be aware that -** experimental interfaces are subject to change in point releases. -** -** These macros used to resolve to various kinds of compiler magic that -** would generate warning messages when they were used. But that -** compiler magic ended up generating such a flurry of bug reports -** that we have taken it all out and gone back to using simple -** noop macros. -*/ -#define SQLITE_DEPRECATED -#define SQLITE_EXPERIMENTAL - -/* -** Ensure these symbols were not defined by some previous header file. -*/ -#ifdef SQLITE_VERSION -# undef SQLITE_VERSION -#endif -#ifdef SQLITE_VERSION_NUMBER -# undef SQLITE_VERSION_NUMBER -#endif - -/* -** CAPI3REF: Compile-Time Library Version Numbers -** -** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header -** evaluates to a string literal that is the SQLite version in the -** format "X.Y.Z" where X is the major version number (always 3 for -** SQLite3) and Y is the minor version number and Z is the release number.)^ -** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer -** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same -** numbers used in [SQLITE_VERSION].)^ -** The SQLITE_VERSION_NUMBER for any given release of SQLite will also -** be larger than the release from which it is derived. Either Y will -** be held constant and Z will be incremented or else Y will be incremented -** and Z will be reset to zero. -** -** Since version 3.6.18, SQLite source code has been stored in the -** Fossil configuration management -** system. ^The SQLITE_SOURCE_ID macro evalutes to -** a string which identifies a particular check-in of SQLite -** within its configuration management system. ^The SQLITE_SOURCE_ID -** string contains the date and time of the check-in (UTC) and an SHA1 -** hash of the entire source tree. -** -** See also: [sqlite3_libversion()], -** [sqlite3_libversion_number()], [sqlite3_sourceid()], -** [sqlite_version()] and [sqlite_source_id()]. -*/ -#define SQLITE_VERSION "3.6.23.1" -#define SQLITE_VERSION_NUMBER 3006023 -#define SQLITE_SOURCE_ID "2010-03-26 22:28:06 b078b588d617e07886ad156e9f54ade6d823568e" - -/* -** CAPI3REF: Run-Time Library Version Numbers -** KEYWORDS: sqlite3_version, sqlite3_sourceid -** -** These interfaces provide the same information as the [SQLITE_VERSION], -** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros -** but are associated with the library instead of the header file. ^(Cautious -** programmers might include assert() statements in their application to -** verify that values returned by these interfaces match the macros in -** the header, and thus insure that the application is -** compiled with matching library and header files. -** -** 
-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==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. -** -** See also: [sqlite_version()] and [sqlite_source_id()]. -*/ -SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; -SQLITE_API const char *sqlite3_libversion(void); -SQLITE_API const char *sqlite3_sourceid(void); -SQLITE_API int sqlite3_libversion_number(void); - -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS -/* -** 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 interating -** 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 specifing 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]. -*/ -SQLITE_API int sqlite3_compileoption_used(const char *zOptName); -SQLITE_API const char *sqlite3_compileoption_get(int N); -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ - -/* -** CAPI3REF: Test To See If The Library Is Threadsafe -** -** ^The sqlite3_threadsafe() function returns zero if and only if -** SQLite was compiled mutexing code omitted due to the -** [SQLITE_THREADSAFE] compile-time option being set to 0. -** -** SQLite can be compiled with or without mutexes. When -** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes -** are enabled and SQLite is threadsafe. When the -** [SQLITE_THREADSAFE] macro is 0, -** the mutexes are omitted. Without the mutexes, it is not safe -** to use SQLite concurrently from more than one thread. -** -** Enabling mutexes incurs a measurable performance penalty. -** So if speed is of utmost importance, it makes sense to disable -** the mutexes. But for maximum safety, mutexes should be enabled. -** ^The default behavior is for mutexes to be enabled. -** -** This interface can be used by an application to make sure that the -** version of SQLite that it is linking against was compiled with -** the desired setting of the [SQLITE_THREADSAFE] macro. -** -** This interface only reports on the compile-time mutex setting -** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with -** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but -** can be fully or partially disabled using a call to [sqlite3_config()] -** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], -** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the -** sqlite3_threadsafe() function shows only the compile-time setting of -** thread safety, not any run-time changes to that setting made by -** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() -** is unchanged by calls to sqlite3_config().)^ -** -** See the [threading mode] documentation for additional information. -*/ -SQLITE_API int sqlite3_threadsafe(void); - -/* -** CAPI3REF: Database Connection Handle -** KEYWORDS: {database connection} {database connections} -** -** Each open SQLite database is represented by a pointer to an instance of -** the opaque structure named "sqlite3". It is useful to think of an sqlite3 -** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and -** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] -** is its destructor. There are many other interfaces (such as -** [sqlite3_prepare_v2()], [sqlite3_create_function()], and -** [sqlite3_busy_timeout()] to name but three) that are methods on an -** sqlite3 object. -*/ -typedef struct sqlite3 sqlite3; - -/* -** CAPI3REF: 64-Bit Integer Types -** KEYWORDS: sqlite_int64 sqlite_uint64 -** -** Because there is no cross-platform way to specify 64-bit integer types -** SQLite includes typedefs for 64-bit signed and unsigned integers. -** -** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. -** The sqlite_int64 and sqlite_uint64 types are supported for backwards -** compatibility only. -** -** ^The sqlite3_int64 and sqlite_int64 types can store integer values -** between -9223372036854775808 and +9223372036854775807 inclusive. ^The -** sqlite3_uint64 and sqlite_uint64 types can store integer values -** between 0 and +18446744073709551615 inclusive. -*/ -#ifdef SQLITE_INT64_TYPE - typedef SQLITE_INT64_TYPE sqlite_int64; - typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; -#elif defined(_MSC_VER) || defined(__BORLANDC__) - typedef __int64 sqlite_int64; - typedef unsigned __int64 sqlite_uint64; -#else - typedef long long int sqlite_int64; - typedef unsigned long long int sqlite_uint64; -#endif -typedef sqlite_int64 sqlite3_int64; -typedef sqlite_uint64 sqlite3_uint64; - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite3_int64 -#endif - -/* -** CAPI3REF: Closing A Database Connection -** -** ^The sqlite3_close() routine is the destructor for the [sqlite3] object. -** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is -** successfullly destroyed and all associated resources are deallocated. -** -** Applications must [sqlite3_finalize | finalize] all [prepared statements] -** and [sqlite3_blob_close | close] all [BLOB handles] associated with -** the [sqlite3] object prior to attempting to close the object. ^If -** sqlite3_close() is called on a [database connection] that still has -** outstanding [prepared statements] or [BLOB handles], then it returns -** SQLITE_BUSY. -** -** ^If [sqlite3_close()] is invoked while a transaction is open, -** the transaction is automatically rolled back. -** -** The C parameter to [sqlite3_close(C)] must be either a NULL -** pointer or an [sqlite3] object pointer obtained -** from [sqlite3_open()], [sqlite3_open16()], or -** [sqlite3_open_v2()], and not previously closed. -** ^Calling sqlite3_close() with a NULL pointer argument is a -** harmless no-op. -*/ -SQLITE_API int sqlite3_close(sqlite3 *); - -/* -** The type for a callback function. -** This is legacy and deprecated. It is included for historical -** compatibility and is not documented. -*/ -typedef int (*sqlite3_callback)(void*,int,char**, char**); - -/* -** CAPI3REF: One-Step Query Execution Interface -** -** 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 -** to sqlite3_exec() is relayed through to the 1st argument of each -** callback invocation. ^If the callback pointer to sqlite3_exec() -** is NULL, then no callback is ever invoked and result rows are -** ignored. -** -** ^If an error occurs while evaluating the SQL statements passed into -** sqlite3_exec(), then execution of the current statement stops and -** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() -** is not NULL then any error message is written into memory obtained -** from [sqlite3_malloc()] and passed back through the 5th parameter. -** To avoid memory leaks, the application should invoke [sqlite3_free()] -** on error message strings returned through the 5th parameter of -** of sqlite3_exec() after the error message string is no longer needed. -** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors -** occur, then sqlite3_exec() sets the pointer in its 5th parameter to -** NULL before returning. -** -** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() -** routine returns SQLITE_ABORT without invoking the callback again and -** without running any subsequent SQL statements. -** -** ^The 2nd argument to the sqlite3_exec() callback function is the -** number of columns in the result. ^The 3rd argument to the sqlite3_exec() -** callback is an array of pointers to strings obtained as if from -** [sqlite3_column_text()], one for each column. ^If an element of a -** result row is NULL then the corresponding string pointer for the -** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the -** sqlite3_exec() callback is an array of pointers to strings where each -** entry represents the name of corresponding result column as obtained -** from [sqlite3_column_name()]. -** -** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer -** to an empty string, or a pointer that contains only whitespace and/or -** SQL comments, then no SQL statements are evaluated and the database -** is not changed. -** -** Restrictions: -** -**
    -**
  • The application must insure that the 1st parameter to sqlite3_exec() -** is a valid and open [database connection]. -**
  • The application must not close [database connection] specified by -** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. -**
  • The application must not modify the SQL statement text passed into -** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. -**
-*/ -SQLITE_API int sqlite3_exec( - sqlite3*, /* An open database */ - const char *sql, /* SQL to be evaluated */ - int (*callback)(void*,int,char**,char**), /* Callback function */ - void *, /* 1st argument to callback */ - char **errmsg /* Error msg written here */ -); - -/* -** CAPI3REF: Result Codes -** KEYWORDS: SQLITE_OK {error code} {error codes} -** KEYWORDS: {result code} {result codes} -** -** Many SQLite functions return an integer result code from the set shown -** here in order to indicates success or failure. -** -** New error codes may be added in future versions of SQLite. -** -** See also: [SQLITE_IOERR_READ | extended result codes] -*/ -#define SQLITE_OK 0 /* Successful result */ -/* beginning-of-error-codes */ -#define SQLITE_ERROR 1 /* SQL error or missing database */ -#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ -#define SQLITE_PERM 3 /* Access permission denied */ -#define SQLITE_ABORT 4 /* Callback routine requested an abort */ -#define SQLITE_BUSY 5 /* The database file is locked */ -#define SQLITE_LOCKED 6 /* A table in the database is locked */ -#define SQLITE_NOMEM 7 /* A malloc() failed */ -#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ -#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ -#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ -#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ -#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ -#define SQLITE_FULL 13 /* Insertion failed because database is full */ -#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ -#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ -#define SQLITE_EMPTY 16 /* Database is empty */ -#define SQLITE_SCHEMA 17 /* The database schema changed */ -#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ -#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ -#define SQLITE_MISMATCH 20 /* Data type mismatch */ -#define SQLITE_MISUSE 21 /* Library used incorrectly */ -#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ -#define SQLITE_AUTH 23 /* Authorization denied */ -#define SQLITE_FORMAT 24 /* Auxiliary database format error */ -#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ -#define SQLITE_NOTADB 26 /* File opened that is not a database file */ -#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ -#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ -/* end-of-error-codes */ - -/* -** CAPI3REF: Extended Result Codes -** KEYWORDS: {extended error code} {extended error codes} -** KEYWORDS: {extended result code} {extended result codes} -** -** In its default configuration, SQLite API routines return one of 26 integer -** [SQLITE_OK | result codes]. However, experience has shown that many of -** these result codes are too coarse-grained. They do not provide as -** much information about problems as programmers might like. In an effort to -** address this, newer versions of SQLite (version 3.3.8 and later) include -** support for additional result codes that provide more detailed information -** about errors. The extended result codes are enabled or disabled -** on a per database connection basis using the -** [sqlite3_extended_result_codes()] API. -** -** Some of the available extended result codes are listed here. -** One may expect the number of extended result codes will be expand -** over time. Software that uses extended result codes should expect -** to see new result codes in future releases of SQLite. -** -** The SQLITE_OK result code will never be extended. It will always -** be exactly zero. -*/ -#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) -#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) -#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) -#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) -#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) -#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) -#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) -#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) -#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) -#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) -#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) -#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) -#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) -#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) -#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) -#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) -#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) -#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8) ) - -/* -** CAPI3REF: Flags For File Open Operations -** -** These bit values are intended for use in the -** 3rd parameter to the [sqlite3_open_v2()] interface and -** in the 4th parameter to the xOpen method of the -** [sqlite3_vfs] object. -*/ -#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ -#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ -#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ -#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ -#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ -#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ -#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ -#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ -#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ -#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ -#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ - -/* -** CAPI3REF: Device Characteristics -** -** The xDeviceCapabilities method of the [sqlite3_io_methods] -** object returns an integer which is a vector of the these -** bit values expressing I/O characteristics of the mass storage -** device that holds the file that the [sqlite3_io_methods] -** refers to. -** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -*/ -#define SQLITE_IOCAP_ATOMIC 0x00000001 -#define SQLITE_IOCAP_ATOMIC512 0x00000002 -#define SQLITE_IOCAP_ATOMIC1K 0x00000004 -#define SQLITE_IOCAP_ATOMIC2K 0x00000008 -#define SQLITE_IOCAP_ATOMIC4K 0x00000010 -#define SQLITE_IOCAP_ATOMIC8K 0x00000020 -#define SQLITE_IOCAP_ATOMIC16K 0x00000040 -#define SQLITE_IOCAP_ATOMIC32K 0x00000080 -#define SQLITE_IOCAP_ATOMIC64K 0x00000100 -#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 -#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 - -/* -** CAPI3REF: File Locking Levels -** -** 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(). -*/ -#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 xOpen method sets the sqlite3_file.pMethods element -** to a non-NULL pointer, then the sqlite3_io_methods.xClose method -** may be invoked even if the xOpen reported that it failed. The -** only way to prevent a call to xClose following a failed xOpen -** is for the xOpen to set the sqlite3_file.pMethods element to NULL. -** -** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or -** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). -** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] -** flag may be ORed in to indicate that only the data of the file -** and not its inode needs to be synced. -** -** The integer values to xLock() and xUnlock() are one of -**
    -**
  • [SQLITE_LOCK_NONE], -**
  • [SQLITE_LOCK_SHARED], -**
  • [SQLITE_LOCK_RESERVED], -**
  • [SQLITE_LOCK_PENDING], or -**
  • [SQLITE_LOCK_EXCLUSIVE]. -**
-** xLock() increases the lock. xUnlock() decreases the lock. -** The xCheckReservedLock() method checks whether any database connection, -** either in this process or in some other process, is holding a RESERVED, -** PENDING, or EXCLUSIVE lock on the file. It returns true -** if such a lock exists and false otherwise. -** -** The xFileControl() method is a generic interface that allows custom -** VFS implementations to directly control an open file using the -** [sqlite3_file_control()] interface. The second "op" argument is an -** integer opcode. The third argument is a generic pointer intended to -** point to a structure that may contain arguments or space in which to -** write return values. Potential uses for xFileControl() might be -** functions to enable blocking locks with timeouts, to change the -** locking strategy (for example to use dot-file locks), to inquire -** about the status of a lock, or to break stale locks. The SQLite -** core reserves all opcodes less than 100 for its own use. -** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. -** Applications that define a custom xFileControl method should use opcodes -** greater than 100 to avoid conflicts. -** -** The xSectorSize() method returns the sector size of the -** device that underlies the file. The sector size is the -** minimum write that can be performed without disturbing -** other bytes in the file. The xDeviceCharacteristics() -** method returns a bit vector describing behaviors of the -** underlying device: -** -**
    -**
  • [SQLITE_IOCAP_ATOMIC] -**
  • [SQLITE_IOCAP_ATOMIC512] -**
  • [SQLITE_IOCAP_ATOMIC1K] -**
  • [SQLITE_IOCAP_ATOMIC2K] -**
  • [SQLITE_IOCAP_ATOMIC4K] -**
  • [SQLITE_IOCAP_ATOMIC8K] -**
  • [SQLITE_IOCAP_ATOMIC16K] -**
  • [SQLITE_IOCAP_ATOMIC32K] -**
  • [SQLITE_IOCAP_ATOMIC64K] -**
  • [SQLITE_IOCAP_SAFE_APPEND] -**
  • [SQLITE_IOCAP_SEQUENTIAL] -**
-** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -** -** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill -** in the unread portions of the buffer with zeros. A VFS that -** fails to zero-fill short reads might seem to work. However, -** failure to zero-fill short reads will eventually lead to -** database corruption. -*/ -typedef struct sqlite3_io_methods sqlite3_io_methods; -struct sqlite3_io_methods { - int iVersion; - int (*xClose)(sqlite3_file*); - int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); - int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); - int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); - int (*xSync)(sqlite3_file*, int flags); - int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); - int (*xLock)(sqlite3_file*, int); - int (*xUnlock)(sqlite3_file*, int); - int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); - int (*xFileControl)(sqlite3_file*, int op, void *pArg); - int (*xSectorSize)(sqlite3_file*); - int (*xDeviceCharacteristics)(sqlite3_file*); - /* Additional methods may be added in future releases */ -}; - -/* -** CAPI3REF: Standard File Control Opcodes -** -** These integer constants are opcodes for the xFileControl method -** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] -** interface. -** -** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This -** opcode causes the xFileControl method to write the current state of -** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], -** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) -** into an integer that the pArg argument points to. This capability -** is used during testing and only needs to be supported when SQLITE_TEST -** is defined. -*/ -#define SQLITE_FCNTL_LOCKSTATE 1 -#define SQLITE_GET_LOCKPROXYFILE 2 -#define SQLITE_SET_LOCKPROXYFILE 3 -#define SQLITE_LAST_ERRNO 4 - -/* -** CAPI3REF: Mutex Handle -** -** The mutex module within SQLite defines [sqlite3_mutex] to be an -** abstract type for a mutex object. The SQLite core never looks -** at the internal representation of an [sqlite3_mutex]. It only -** deals with pointers to the [sqlite3_mutex] object. -** -** Mutexes are created using [sqlite3_mutex_alloc()]. -*/ -typedef struct sqlite3_mutex sqlite3_mutex; - -/* -** CAPI3REF: OS Interface Object -** -** An instance of the sqlite3_vfs object defines the interface between -** the SQLite core and the underlying operating system. The "vfs" -** in the name of the object stands for "virtual file system". -** -** The value of the iVersion field is initially 1 but may be larger in -** future versions of SQLite. Additional fields may be appended to this -** object when the iVersion value is increased. Note that the structure -** of the sqlite3_vfs object changes in the transaction between -** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not -** modified. -** -** The szOsFile field is the size of the subclassed [sqlite3_file] -** structure used by this VFS. mxPathname is the maximum length of -** a pathname in this VFS. -** -** Registered sqlite3_vfs objects are kept on a linked list formed by -** the pNext pointer. The [sqlite3_vfs_register()] -** and [sqlite3_vfs_unregister()] interfaces manage this list -** in a thread-safe way. The [sqlite3_vfs_find()] interface -** searches the list. Neither the application code nor the VFS -** implementation should use the pNext pointer. -** -** The pNext field is the only field in the sqlite3_vfs -** structure that SQLite will ever modify. SQLite will only access -** or modify this field while holding a particular static mutex. -** The application should never modify anything within the sqlite3_vfs -** object once the object has been registered. -** -** The zName field holds the name of the VFS module. The name must -** be unique across all VFS modules. -** -** SQLite will guarantee that the zFilename parameter to xOpen -** is either a NULL pointer or string obtained -** from xFullPathname(). SQLite further guarantees that -** the string will be valid and unchanged until xClose() is -** called. Because of the previous sentence, -** the [sqlite3_file] can safely store a pointer to the -** filename if it needs to remember the filename for some reason. -** If the zFilename parameter is xOpen is a NULL pointer then xOpen -** must invent its own temporary name for the file. Whenever the -** xFilename parameter is NULL it will also be the case that the -** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. -** -** The flags argument to xOpen() includes all bits set in -** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] -** or [sqlite3_open16()] is used, then flags includes at least -** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. -** If xOpen() opens a file read-only then it sets *pOutFlags to -** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. -** -** SQLite will also add one of the following flags to the xOpen() -** call, depending on the object being opened: -** -**
    -**
  • [SQLITE_OPEN_MAIN_DB] -**
  • [SQLITE_OPEN_MAIN_JOURNAL] -**
  • [SQLITE_OPEN_TEMP_DB] -**
  • [SQLITE_OPEN_TEMP_JOURNAL] -**
  • [SQLITE_OPEN_TRANSIENT_DB] -**
  • [SQLITE_OPEN_SUBJOURNAL] -**
  • [SQLITE_OPEN_MASTER_JOURNAL] -**
-** -** 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: -** -**
    -**
  • [SQLITE_OPEN_DELETEONCLOSE] -**
  • [SQLITE_OPEN_EXCLUSIVE] -**
-** -** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be -** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE] -** will be set for TEMP databases, journals and for subjournals. -** -** The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction -** with the [SQLITE_OPEN_CREATE] flag, which are both directly -** analogous to the O_EXCL and O_CREAT flags of the POSIX open() -** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the -** SQLITE_OPEN_CREATE, is used to indicate that file should always -** be created, and that it is an error if it already exists. -** It is 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. -** -** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] -** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to -** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] -** to test whether a file is at least readable. The file can be a -** directory. -** -** SQLite will always allocate at least mxPathname+1 bytes for the -** output buffer xFullPathname. The exact size of the output buffer -** is also passed as a parameter to both methods. If the output buffer -** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is -** handled as a fatal error by SQLite, vfs implementations should endeavor -** to prevent this by setting mxPathname to a sufficiently large value. -** -** The xRandomness(), xSleep(), and xCurrentTime() interfaces -** are not strictly a part of the filesystem, but they are -** included in the VFS structure for completeness. -** The xRandomness() function attempts to return nBytes bytes -** of good-quality randomness into zOut. The return value is -** the actual number of bytes of randomness obtained. -** The xSleep() method causes the calling thread to sleep for at -** least the number of microseconds given. The xCurrentTime() -** method returns a Julian Day Number for the current date and time. -** -*/ -typedef struct sqlite3_vfs sqlite3_vfs; -struct sqlite3_vfs { - int iVersion; /* Structure version number */ - int szOsFile; /* Size of subclassed sqlite3_file */ - int mxPathname; /* Maximum file pathname length */ - sqlite3_vfs *pNext; /* Next registered VFS */ - const char *zName; /* Name of this virtual file system */ - void *pAppData; /* Pointer to application-specific data */ - int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, - int flags, int *pOutFlags); - int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); - int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); - int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); - void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); - void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); - void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); - void (*xDlClose)(sqlite3_vfs*, void*); - int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); - int (*xSleep)(sqlite3_vfs*, int microseconds); - int (*xCurrentTime)(sqlite3_vfs*, double*); - int (*xGetLastError)(sqlite3_vfs*, int, char *); - /* New fields may be appended in figure versions. The iVersion - ** value will increment whenever this happens. */ -}; - -/* -** CAPI3REF: Flags for the xAccess VFS method -** -** 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 file is both readable and writable. -** With SQLITE_ACCESS_READ, the xAccess method -** checks whether the file is readable. -*/ -#define SQLITE_ACCESS_EXISTS 0 -#define SQLITE_ACCESS_READWRITE 1 -#define SQLITE_ACCESS_READ 2 - -/* -** CAPI3REF: Initialize The SQLite Library -** -** ^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 insure that no other SQLite interfaces are invoked by other -** threads while sqlite3_config() is running. Furthermore, sqlite3_config() -** may only be invoked prior to library initialization using -** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. -** ^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 -** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines -** what property of SQLite is to be configured. Subsequent arguments -** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option] -** in the first argument. -** -** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. -** ^If the option is unknown or SQLite is unable to set the option -** then this routine returns a non-zero [error code]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_config(int, ...); - -/* -** CAPI3REF: Configure database connections -** EXPERIMENTAL -** -** The sqlite3_db_config() interface is used to make configuration -** changes to a [database connection]. The interface is similar to -** [sqlite3_config()] except that the changes apply to a single -** [database connection] (specified in the first argument). The -** sqlite3_db_config() interface should only be used immediately after -** the database connection is created using [sqlite3_open()], -** [sqlite3_open16()], or [sqlite3_open_v2()]. -** -** The second argument to sqlite3_db_config(D,V,...) is the -** configuration verb - an integer code that indicates what -** aspect of the [database connection] is being configured. -** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE]. -** New verbs are likely to be added in future releases of SQLite. -** Additional arguments depend on the verb. -** -** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if -** the call is considered successful. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...); - -/* -** CAPI3REF: Memory Allocation Routines -** EXPERIMENTAL -** -** An instance of this object defines the interface between SQLite -** and low-level memory allocation routines. -** -** This object is used in only one place in the SQLite interface. -** A pointer to an instance of this object is the argument to -** [sqlite3_config()] when the configuration option is -** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. -** By creating an instance of this object -** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) -** during configuration, an application can specify an alternative -** memory allocation subsystem for SQLite to use for all of its -** dynamic memory needs. -** -** Note that SQLite comes with several [built-in memory allocators] -** that are perfectly adequate for the overwhelming majority of applications -** and that this object is only useful to a tiny minority of applications -** with specialized memory allocation requirements. This object is -** also used during testing of SQLite in order to specify an alternative -** memory allocator that simulates memory out-of-memory conditions in -** order to verify that SQLite recovers gracefully from such -** conditions. -** -** The xMalloc and xFree methods must work like the -** malloc() and free() functions from the standard C library. -** The xRealloc method must work like realloc() from the standard C library -** with the exception that if the second argument to xRealloc is zero, -** xRealloc must be a no-op - it must not perform any allocation or -** deallocation. ^SQLite guarantees that the second argument to -** xRealloc is always a value returned by a prior call to xRoundup. -** And so in cases where xRoundup always returns a positive number, -** xRealloc can perform exactly as the standard library realloc() and -** still be in compliance with this specification. -** -** xSize should return the allocated size of a memory allocation -** previously obtained from xMalloc or xRealloc. The allocated size -** is always at least as big as the requested size but may be larger. -** -** The xRoundup method returns what would be the allocated size of -** a memory allocation given a particular requested size. Most memory -** allocators round up memory allocations at least to the next multiple -** of 8. Some allocators round up to a larger multiple or to a power of 2. -** 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 require 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_MASTER] 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 -** EXPERIMENTAL -** -** 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
-**
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
-**
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
-**
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
-**
^(This 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
-**
^(This 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_MEMSTATUS
-**
^This 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_memory_used()] -**
  • [sqlite3_memory_highwater()] -**
  • [sqlite3_soft_heap_limit()] -**
  • [sqlite3_status()] -**
)^ -** ^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
-**
^This option specifies a static memory buffer that SQLite can use for -** scratch memory. There are three arguments: A pointer an 8-byte -** aligned memory buffer from which the scrach allocations will be -** drawn, the size of each scratch allocation (sz), -** and the maximum number of scratch allocations (N). The sz -** argument must be a multiple of 16. The sz parameter should be a few bytes -** larger than the actual scratch space required due to internal overhead. -** The first argument must be a pointer to an 8-byte aligned buffer -** of at least sz*N bytes of memory. -** ^SQLite will use no more than one scratch buffer per thread. So -** N should be set to the expected maximum number of threads. ^SQLite will -** never require a scratch buffer that is more than 6 times the database -** page size. ^If SQLite needs needs additional scratch memory beyond -** what is provided by this configuration option, then -** [sqlite3_malloc()] will be used to obtain the memory needed.
-** -**
SQLITE_CONFIG_PAGECACHE
-**
^This option specifies a static memory buffer that SQLite can use for -** the database page cache with the default page cache implemenation. -** This configuration should not be used if an application-define page -** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option. -** There are three arguments to this option: A pointer to 8-byte aligned -** memory, the size of each page buffer (sz), and the number of pages (N). -** The sz argument should be the size of the largest database page -** (a power of two between 512 and 32768) plus a little extra for each -** page header. ^The page header size is 20 to 40 bytes depending on -** the host architecture. ^It is harmless, apart from the wasted memory, -** to make sz a little too large. The first -** argument should point to an allocation of at least sz*N bytes of memory. -** ^SQLite will use the memory provided by the first argument to satisfy its -** memory needs for the first N pages that it adds to cache. ^If additional -** page cache memory is needed beyond what is provided by this option, then -** SQLite goes to [sqlite3_malloc()] for the additional storage space. -** ^The implementation might use one or more of the N buffers to hold -** memory accounting information. The pointer in the first argument must -** be aligned to an 8-byte boundary or subsequent behavior of SQLite -** will be undefined.
-** -**
SQLITE_CONFIG_HEAP
-**
^This 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_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. -** There are three arguments: 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 and either [SQLITE_ENABLE_MEMSYS3] or -** [SQLITE_ENABLE_MEMSYS5] are defined, 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.
-** -**
SQLITE_CONFIG_MUTEX
-**
^(This 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
-**
^(This 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
-**
^(This option takes two arguments that determine the default -** memory allocation for the lookaside memory allocator 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.)^ ^(This option sets the -** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] -** verb to [sqlite3_db_config()] can be used to change the lookaside -** configuration on individual connections.)^
-** -**
SQLITE_CONFIG_PCACHE
-**
^(This option takes a single argument which is a pointer to -** an [sqlite3_pcache_methods] object. This object specifies the interface -** to a custom page cache implementation.)^ ^SQLite makes a copy of the -** object and uses it for page cache memory allocations.
-** -**
SQLITE_CONFIG_GETPCACHE
-**
^(This option takes a single argument which is a pointer to an -** [sqlite3_pcache_methods] object. SQLite copies of the current -** page cache implementation into that object.)^
-** -**
-*/ -#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 /* void*, int sz, int N */ -#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 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_GETPCACHE 15 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** 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
-**
^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 an 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. See also: [SQLITE_CONFIG_LOOKASIDE]
-** -**
-*/ -#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ - - -/* -** CAPI3REF: Enable Or Disable Extended Result Codes -** -** ^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 -** -** ^Each entry in an SQLite table 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. -** -** ^This routine returns the [rowid] of the most recent -** successful [INSERT] into the database from the [database connection] -** in the first argument. ^If no successful [INSERT]s -** have ever occurred on that database connection, zero is returned. -** -** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted -** row is returned by this routine as long as the trigger is running. -** But once the trigger terminates, the value returned by this routine -** reverts to the last value inserted before the trigger 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: Count The Number Of Rows Modified -** -** ^This function returns the number of database rows that were changed -** or inserted or deleted by the most recently completed SQL statement -** on the [database connection] specified by the first parameter. -** ^(Only changes that are directly specified by the [INSERT], [UPDATE], -** or [DELETE] statement are counted. Auxiliary changes caused by -** triggers or [foreign key actions] are not counted.)^ Use the -** [sqlite3_total_changes()] function to find the total number of changes -** including changes caused by triggers and foreign key actions. -** -** ^Changes to a view that are simulated by an [INSTEAD OF trigger] -** are not counted. Only real table changes are counted. -** -** ^(A "row change" is a change to a single row of a single table -** caused by an INSERT, DELETE, or UPDATE statement. Rows that -** are changed as side effects of [REPLACE] constraint resolution, -** rollback, ABORT processing, [DROP TABLE], or by any other -** mechanisms do not count as direct row changes.)^ -** -** A "trigger context" is a scope of execution that begins and -** ends with the script of a [CREATE TRIGGER | trigger]. -** Most SQL statements are -** evaluated outside of any trigger. This is the "top level" -** trigger context. If a trigger fires from the top level, a -** new trigger context is entered for the duration of that one -** trigger. Subtriggers create subcontexts for their duration. -** -** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does -** not create a new trigger context. -** -** ^This function returns the number of direct row changes in the -** most recent INSERT, UPDATE, or DELETE statement within the same -** trigger context. -** -** ^Thus, when called from the top level, this function returns the -** number of changes in the most recent INSERT, UPDATE, or DELETE -** that also occurred at the top level. ^(Within the body of a trigger, -** the sqlite3_changes() interface can be called to find the number of -** changes in the most recently completed INSERT, UPDATE, or DELETE -** statement within the body of the same trigger. -** However, the number returned does not include changes -** caused by subtriggers since those have their own context.)^ -** -** See also the [sqlite3_total_changes()] interface, the -** [count_changes pragma], and the [changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_changes(sqlite3*); - -/* -** CAPI3REF: Total Number Of Rows Modified -** -** ^This function returns the number of row changes caused by [INSERT], -** [UPDATE] or [DELETE] statements since the [database connection] was opened. -** ^(The count returned by sqlite3_total_changes() includes all changes -** from all [CREATE TRIGGER | trigger] contexts and changes made by -** [foreign key actions]. However, -** the count does not include changes used to implement [REPLACE] constraints, -** do rollbacks or ABORT processing, or [DROP TABLE] processing. The -** count does not include rows of views that fire an [INSTEAD OF trigger], -** though if the INSTEAD OF trigger makes changes of its own, those changes -** are counted.)^ -** ^The sqlite3_total_changes() function counts the changes as soon as -** the statement that makes them is completed (when the statement handle -** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). -** -** See also the [sqlite3_changes()] interface, the -** [count_changes pragma], and the [total_changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_total_changes(sqlite3*); - -/* -** CAPI3REF: Interrupt A Long-Running Query -** -** ^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 statements 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. -** -** If the database connection closes while [sqlite3_interrupt()] -** is running then bad things will likely happen. -*/ -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 -** -** ^This routine sets a callback function that might be invoked whenever -** an attempt is made to open a database table that another thread -** or process has locked. -** -** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] -** 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 for this locking event. ^If the -** busy callback returns 0, then no additional attempts are made to -** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. -** ^If the callback returns non-zero, then another attempt -** is made to open the database for reading 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] -** or [SQLITE_IOERR_BLOCKED] 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. -** -** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] -** when SQLite is in the middle of a large transaction where all the -** changes will not fit into the in-memory cache. SQLite will -** already hold a RESERVED lock on the database file, but it needs -** to promote this lock to EXCLUSIVE so that it can spill cache -** pages into the database file without harm to concurrent -** readers. ^If it is unable to promote the lock, then the in-memory -** cache will be left in an inconsistent state and so the error -** code is promoted from the relatively benign [SQLITE_BUSY] to -** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion -** forces an automatic rollback of the changes. See the -** -** CorruptionFollowingBusyError wiki page for a discussion of why -** this is important. -** -** ^(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()] -** will also set or clear the busy handler. -** -** The busy callback should not take any actions which modify the -** database connection that invoked the busy handler. 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 -** -** ^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] or [SQLITE_IOERR_BLOCKED]. -** -** ^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] any any given moment. If another busy handler -** was defined (using [sqlite3_busy_handler()]) prior to calling -** this routine, that other busy handler is cleared.)^ -*/ -SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); - -/* -** CAPI3REF: Convenience Routines For Running Queries -** -** 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 column (M==2) and three rows (N==3). Thus the -** result table has 8 entries. Suppose the result table is stored -** in an array names 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 should 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. -** -** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their -** results into memory obtained from [sqlite3_malloc()]. -** The strings returned by these two routines should be -** released by [sqlite3_free()]. ^Both routines return a -** NULL pointer if [sqlite3_malloc()] is unable to allocate enough -** memory to hold the resulting string. -** -** ^(In 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. -** -** These routines all implement some additional formatting -** options that are useful for constructing SQL statements. -** All of the usual printf() formatting options apply. In addition, there -** is are "%q", "%Q", and "%z" options. -** -** ^(The %q option works like %s in that it substitutes a null-terminated -** string from the argument list. But %q also doubles every '\'' character. -** %q is designed for use inside a string literal.)^ By doubling each '\'' -** character it escapes that character and allows it to be inserted into -** the string. -** -** For example, assume the string variable zText contains text as follows: -** -** 
-**  char *zText = "It's a happy day!";
-**
-** -** One can use this text in an SQL statement as follows: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** Because the %q format string is used, the '\'' character in zText -** is escaped and the SQL generated is as follows: -** -** 
-**  INSERT INTO table1 VALUES('It''s a happy day!')
-**
-** -** This is correct. Had we used %s instead of %q, the generated SQL -** would have looked like this: -** -** 
-**  INSERT INTO table1 VALUES('It's a happy day!');
-**
-** -** This second example is an SQL syntax error. As a general rule you should -** always use %q instead of %s when inserting text into a string literal. -** -** ^(The %Q option works like %q except it also adds single quotes around -** the outside of the total string. Additionally, if the parameter in the -** argument list is a NULL pointer, %Q substitutes the text "NULL" (without -** single quotes).)^ So, for example, one could say: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** The code above will render a correct SQL statement in the zSQL -** variable even if the zText variable is a NULL pointer. -** -** ^(The "%z" formatting option works like "%s" but with the -** addition that after the string has been read and copied into -** the result, [sqlite3_free()] is called on the input string.)^ -*/ -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*, ...); - -/* -** 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. -** -** ^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() interface attempts to resize a -** prior memory allocation to be at least N bytes, where N is the -** second parameter. The memory allocation to be resized is the first -** parameter.)^ ^ If the first parameter to sqlite3_realloc() -** is a NULL pointer then its behavior is identical to calling -** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). -** ^If the second parameter to sqlite3_realloc() is zero or -** negative then the behavior is exactly the same as calling -** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). -** ^sqlite3_realloc() returns a pointer to a memory allocation -** of at least N bytes in size or NULL if sufficient memory is unavailable. -** ^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() and the prior allocation is freed. -** ^If sqlite3_realloc() returns NULL, then the prior allocation -** is not freed. -** -** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() -** is always aligned to at least an 8 byte boundary. -** -** In SQLite version 3.5.0 and 3.5.1, it was possible to define -** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in -** implementation of these routines to be omitted. That capability -** is no longer provided. Only built-in memory allocators can be used. -** -** The Windows OS interface layer calls -** the system malloc() and free() directly when converting -** filenames between the UTF-8 encoding used by SQLite -** and whatever filename encoding is used by the particular Windows -** installation. Memory allocation errors are detected, but -** they are reported back as [SQLITE_CANTOPEN] or -** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. -** -** 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_realloc(void*, int); -SQLITE_API void sqlite3_free(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 build-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 first time this routine is invoked (either internally or by -** the application) the PRNG is seeded using randomness obtained -** from the xRandomness method of the default [sqlite3_vfs] object. -** ^On all subsequent invocations, 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 -** -** ^This routine registers a 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_prepare16()] and [sqlite3_prepare16_v2()]. ^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 zero-terminated strings that contain additional -** details about the action to be authorized. -** -** ^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. -** ^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. -*/ -#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 */ - -/* -** CAPI3REF: Tracing And Profiling Functions -** EXPERIMENTAL -** -** 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 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. -*/ -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, - void(*xProfile)(void*,const char*,sqlite3_uint64), void*); - -/* -** CAPI3REF: Query Progress Callbacks -** -** ^This routine configures a callback function - the -** progress callback - that is invoked periodically during long -** running calls to [sqlite3_exec()], [sqlite3_step()] and -** [sqlite3_get_table()]. An example use for this -** interface is to keep a GUI updated during a large query. -** -** ^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 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 -** -** ^These routines open an SQLite database file whose name is given 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 for the database will be UTF-8 if -** sqlite3_open() or sqlite3_open_v2() is called and -** UTF-16 in the native byte order if sqlite3_open16() is used. -** -** 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() can take one of -** the following three values, optionally combined with the -** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], -** and/or [SQLITE_OPEN_PRIVATECACHE] flags:)^ -** -**
-** ^(
[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 creates it if -** it does not already exist. This is the behavior that is always used for -** sqlite3_open() and sqlite3_open16().
)^ -**
-** -** If the 3rd parameter to sqlite3_open_v2() is not one of the -** combinations shown above or one of the combinations shown above combined -** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], -** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags, -** then the behavior is undefined. -** -** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection -** opens in the multi-thread [threading mode] as long as the single-thread -** mode has not been set at compile-time or start-time. ^If the -** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens -** in the serialized [threading mode] unless single-thread was -** previously selected at compile-time or start-time. -** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be -** eligible to use [shared cache mode], regardless of whether or not shared -** cache is enabled using [sqlite3_enable_shared_cache()]. ^The -** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not -** participate in [shared cache mode] even if it is enabled. -** -** ^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. -** -** ^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. -** -** 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(). -*/ -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: Error Codes And Messages -** -** ^The sqlite3_errcode() interface returns the numeric [result code] or -** [extended result code] for the most recent failed sqlite3_* API call -** associated with a [database connection]. If a prior API call failed -** but the most recent API call succeeded, the return value from -** sqlite3_errcode() is undefined. ^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 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.)^ -** -** 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*); - -/* -** CAPI3REF: SQL Statement Object -** KEYWORDS: {prepared statement} {prepared statements} -** -** An instance of this object represents a single SQL statement. -** This object is variously known as a "prepared statement" or a -** "compiled SQL statement" or simply as a "statement". -** -** The life of a statement object goes something like this: -** -**
    -**
  1. Create the object using [sqlite3_prepare_v2()] or a related -** function. -**
  2. Bind values to [host parameters] using the sqlite3_bind_*() -** interfaces. -**
  3. Run the SQL by calling [sqlite3_step()] one or more times. -**
  4. Reset the statement using [sqlite3_reset()] then go back -** to step 2. Do this zero or more times. -**
  5. Destroy the object using [sqlite3_finalize()]. -**
-** -** Refer to documentation on individual methods above for additional -** information. -*/ -typedef struct sqlite3_stmt sqlite3_stmt; - -/* -** CAPI3REF: Run-time Limits -** -** ^(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. The function returns the old limit.)^ -** -** ^If the new limit is a negative number, the limit is unchanged. -** ^(For the limit category of SQLITE_LIMIT_XYZ there is a -** [limits | hard upper bound] -** set by a compile-time C preprocessor macro named -** [limits | SQLITE_MAX_XYZ]. -** (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. -** -** 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
-**
The maximum size of any string or BLOB or table row.
)^ -** -** ^(
SQLITE_LIMIT_SQL_LENGTH
-**
The maximum length of an SQL statement, in bytes.
)^ -** -** ^(
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
-**
The maximum depth of the parse tree on any expression.
)^ -** -** ^(
SQLITE_LIMIT_COMPOUND_SELECT
-**
The maximum number of terms in a compound SELECT statement.
)^ -** -** ^(
SQLITE_LIMIT_VDBE_OP
-**
The maximum number of instructions in a virtual machine program -** used to implement an SQL statement.
)^ -** -** ^(
SQLITE_LIMIT_FUNCTION_ARG
-**
The maximum number of arguments on a function.
)^ -** -** ^(
SQLITE_LIMIT_ATTACHED
-**
The maximum number of [ATTACH | attached databases].)^
-** -** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
-**
The maximum length of the pattern argument to the [LIKE] or -** [GLOB] operators.
)^ -** -** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
-**
The maximum number of variables in an SQL statement that can -** be bound.
)^ -** -** ^(
SQLITE_LIMIT_TRIGGER_DEPTH
-**
The maximum depth of recursion for triggers.
)^ -**
-*/ -#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 - -/* -** CAPI3REF: Compiling An SQL Statement -** KEYWORDS: {SQL statement compiler} -** -** To execute an SQL query, it must first be compiled into a byte-code -** program using one of these routines. -** -** 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() and sqlite3_prepare_v2() -** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() -** use UTF-16. -** -** ^If the nByte argument is less than zero, then zSql is read up to the -** first zero terminator. ^If nByte is non-negative, then it is the maximum -** number of bytes read from zSql. ^When nByte is non-negative, the -** zSql string ends at either the first '\000' or '\u0000' character or -** the nByte-th byte, whichever comes first. If the caller knows -** that the supplied string is nul-terminated, then there is a small -** performance advantage to be gained by passing an nByte parameter that -** is equal to the number of bytes in the input string including -** the nul-terminator bytes. -** -** ^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() and sqlite3_prepare16_v2() interfaces are -** recommended for all new programs. The two older interfaces are retained -** for backwards compatibility, but their use is discouraged. -** ^In the "v2" 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. ^If the schema has changed in -** a way that makes the statement no longer valid, [sqlite3_step()] will still -** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is -** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the -** error go away. Note: use [sqlite3_errmsg()] to find the text -** of the parsing error that results in an [SQLITE_SCHEMA] return. -**
    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 value of a [parameter | host parameter] in the WHERE clause might -** change the query plan for a statement, then the statement may 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 the [parameter]. -**
    4. -**
-*/ -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_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 */ -); - -/* -** CAPI3REF: Retrieving Statement SQL -** -** ^This interface can be used to retrieve a saved copy of the original -** SQL text used to create a [prepared statement] if that statement was -** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. -*/ -SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); - -/* -** 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 terms "protected" and "unprotected" refer to whether or not -** a mutex is held. A 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 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 with -** [sqlite3_result_value()] and [sqlite3_bind_value()]. -** The [sqlite3_value_blob | sqlite3_value_type()] family of -** interfaces require protected sqlite3_value objects. -*/ -typedef struct Mem 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} -** -** ^(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: -** -**
    -**
  • ? -**
  • ?NNN -**
  • :VVV -**
  • @VVV -**
  • $VVV -**
-** -** In the templates above, NNN represents an integer literal, -** and VVV represents an alphanumeric identifer.)^ ^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: 999). -** -** ^The third argument is the value to bind to the parameter. -** -** ^(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 is negative, the length of the string is -** the number of bytes up to the first zero terminator. -** -** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and -** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^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 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. -** -** ^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_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_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 n, void(*)(void*)); -SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); -SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); -SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); - -/* -** CAPI3REF: Number Of SQL Parameters -** -** ^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 -** -** ^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()] or -** [sqlite3_prepare16_v2()]. -** -** 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 -** -** ^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()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); - -/* -** CAPI3REF: Reset All Bindings On A Prepared Statement -** -** ^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 -** -** ^Return the number of columns in the result set returned by the -** [prepared statement]. ^This routine returns 0 if pStmt is an SQL -** statement that does not return data (for example an [UPDATE]). -*/ -SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Column Names In A Result Set -** -** ^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 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 -** -** ^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 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 routine 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 of these routines against the same -** prepared statement and column at the same time then the results are -** undefined. -** -** 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 -** -** ^(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 -** -** After a [prepared statement] has been prepared using either -** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] 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 "v2" interface -** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy -** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the -** new "v2" 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 a -** 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. -** -** 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 either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] 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 "v2" interface is recommended. -*/ -SQLITE_API int sqlite3_step(sqlite3_stmt*); - -/* -** CAPI3REF: Number of columns in a result set -** -** ^The sqlite3_data_count(P) the number of columns in the -** of the result set of [prepared statement] P. -*/ -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: -** -**
    -**
  • 64-bit signed integer -**
  • 64-bit IEEE floating point number -**
  • string -**
  • BLOB -**
  • NULL -**
)^ -** -** 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} -** -** These routines form the "result set" interface. -** -** ^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 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 value -** returned by sqlite3_column_type() is only meaningful if no type -** conversions have occurred as described below. After a type conversion, -** the value returned by sqlite3_column_type() is undefined. Future -** versions of SQLite may change the behavior of sqlite3_column_type() -** following a type conversion. -** -** ^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. -** ^The value returned does not include the zero terminator at the end -** of the string. ^For clarity: the value returned is 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 an arbitrary -** pointer, possibly even a NULL pointer. -** -** ^The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() -** but leaves the result in UTF-16 in native byte order instead of UTF-8. -** ^The zero terminator is not included in this count. -** -** ^The object returned by [sqlite3_column_value()] is an -** [unprotected sqlite3_value] object. An unprotected sqlite3_value object -** may only be used 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()], then the behavior is undefined. -** -** These routines attempt to convert the value where appropriate. ^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 NULL pointer -**
NULL BLOB Result is NULL pointer -**
INTEGER FLOAT Convert from integer to float -**
INTEGER TEXT ASCII rendering of the integer -**
INTEGER BLOB Same as INTEGER->TEXT -**
FLOAT INTEGER Convert from float to integer -**
FLOAT TEXT ASCII rendering of the float -**
FLOAT BLOB Same as FLOAT->TEXT -**
TEXT INTEGER Use atoi() -**
TEXT FLOAT Use atof() -**
TEXT BLOB No change -**
BLOB INTEGER Convert to TEXT then use atoi() -**
BLOB FLOAT Convert to TEXT then use atof() -**
BLOB TEXT Add a zero terminator if needed -**
-** )^ -** -** The table above makes reference to standard C library functions atoi() -** and atof(). SQLite does not really use these functions. It has its -** own equivalent internal routines. The atoi() and atof() names are -** used in the table for brevity and because they are familiar to most -** C programmers. -** -** ^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: -** -**
    -**
  • The initial content is a BLOB and sqlite3_column_text() or -** sqlite3_column_text16() is called. A zero-terminator might -** need to be added to the string.
    • -**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or -** sqlite3_column_text16() is called. The content must be converted -** to UTF-16.
    • -**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or -** sqlite3_column_text() is called. The content must be converted -** to UTF-8.
    • -**
)^ -** -** ^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 points to 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 and easiest to remember policy is to invoke these routines -** in one of the following ways: -** -**
    -**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • -**
)^ -** -** 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 -** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into -** [sqlite3_free()]. -** -** ^(If a memory allocation error occurs during the evaluation of any -** of these routines, a default value is returned. The default value -** is either the integer 0, the floating point number 0.0, or a NULL -** pointer. Subsequent calls to [sqlite3_errcode()] will return -** [SQLITE_NOMEM].)^ -*/ -SQLITE_API const void *sqlite3_column_blob(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 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 int sqlite3_column_type(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); - -/* -** CAPI3REF: Destroy A Prepared Statement Object -** -** ^The sqlite3_finalize() function is called to delete a [prepared statement]. -** ^If the statement was executed successfully or not executed at all, then -** SQLITE_OK is returned. ^If execution of the statement failed then an -** [error code] or [extended error code] is returned. -** -** ^This routine can be called at any point during the execution of the -** [prepared statement]. ^If the virtual machine has not -** completed execution when this routine is called, that is like -** encountering an error or an [sqlite3_interrupt | interrupt]. -** ^Incomplete updates may be rolled back and transactions canceled, -** depending on the circumstances, and the -** [error code] returned will be [SQLITE_ABORT]. -*/ -SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Reset A Prepared Statement Object -** -** 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} -** KEYWORDS: {application-defined SQL function} -** KEYWORDS: {application-defined SQL functions} -** -** ^These two 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 difference between the -** two is that the second parameter, the name of the (scalar) function or -** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16 -** for sqlite3_create_function16(). -** -** ^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, exclusive of -** the zero-terminator. Note that the name length limit is in bytes, not -** characters. ^Any attempt to create a function with a longer name -** will result in [SQLITE_ERROR] 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. Any SQL function implementation should be able to work -** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be -** more efficient with one encoding than another. ^An application may -** invoke sqlite3_create_function() or sqlite3_create_function16() multiple -** times with the same function but with different values of eTextRep. -** ^When multiple implementations of the same function are available, SQLite -** will pick the one that involves the least amount of data conversion. -** If there is only a single implementation which does not care what text -** encoding is used, then the fourth argument should be [SQLITE_ANY]. -** -** ^(The fifth parameter is an arbitrary pointer. The implementation of the -** function can gain access to this pointer using [sqlite3_user_data()].)^ -** -** The seventh, eighth and ninth parameters, 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 should be passed as the xStep and xFinal -** parameters. ^An aggregate SQL function requires an implementation of xStep -** and xFinal and NULL should be passed for xFunc. ^To delete an existing -** SQL function or aggregate, pass NULL for all three function callbacks. -** -** ^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. -** ^The first application-defined function with a given name overrides all -** built-in functions in the same [database connection] with the same name. -** ^Subsequent application-defined functions of the same name only override -** prior application-defined functions that are an exact match for the -** number of parameters and preferred encoding. -** -** ^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*) -); - -/* -** CAPI3REF: Text Encodings -** -** These constant define integer codes that represent the various -** text encodings supported by SQLite. -*/ -#define SQLITE_UTF8 1 -#define SQLITE_UTF16LE 2 -#define SQLITE_UTF16BE 3 -#define SQLITE_UTF16 4 /* Use native byte order */ -#define SQLITE_ANY 5 /* sqlite3_create_function only */ -#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ - -/* -** 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 help encourage people to avoid -** using these functions, we are not going to tell you 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 Function Parameter Values -** -** The C-language implementation of SQL functions and aggregates uses -** this set of interface routines to access the parameter values on -** the function or aggregate. -** -** The xFunc (for scalar functions) or xStep (for aggregates) parameters -** to [sqlite3_create_function()] and [sqlite3_create_function16()] -** define callbacks that implement the SQL functions and aggregates. -** The 4th parameter to these callbacks is an array of pointers to -** [protected sqlite3_value] objects. There is one [sqlite3_value] object for -** each parameter to the SQL function. These routines are used to -** extract values from the [sqlite3_value] objects. -** -** These routines work only with [protected sqlite3_value] objects. -** Any attempt to use these routines on an [unprotected sqlite3_value] -** object results in undefined behavior. -** -** ^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. -** -** ^(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.)^ -** -** 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. -*/ -SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes16(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 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_type(sqlite3_value*); -SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); - -/* -** CAPI3REF: Obtain Aggregate Function Context -** -** Implementions 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 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 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 subsequent call to sqlite3_aggregate_context() within -** the same aggregate function instance will not resize the memory -** allocation.)^ -** -** ^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 -** -** ^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 -** -** ^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 -** -** The following two functions may be used by scalar 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. This may -** be used, for example, to add a regular-expression matching scalar -** function. The compiled version of the regular expression is stored as -** metadata associated with the SQL value passed as the regular expression -** pattern. The compiled regular expression can be reused on multiple -** invocations of the same function so that the original pattern string -** does not need to be recompiled on each invocation. -** -** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata -** associated by the sqlite3_set_auxdata() function with the Nth argument -** value to the application-defined function. ^If no metadata has been ever -** been set for the Nth argument of the function, or if the corresponding -** function parameter has changed since the meta-data was set, -** then sqlite3_get_auxdata() returns a NULL pointer. -** -** ^The sqlite3_set_auxdata() interface saves the metadata -** pointed to by its 3rd parameter as the metadata for the N-th -** argument of the application-defined function. Subsequent -** calls to sqlite3_get_auxdata() might return this data, if it has -** not been destroyed. -** ^If it is not NULL, SQLite will invoke the destructor -** function given by the 4th parameter to sqlite3_set_auxdata() on -** the metadata when the corresponding function parameter changes -** or when the SQL statement completes, whichever comes first. -** -** SQLite is free to call the destructor and drop metadata on any -** parameter of any function at any time. ^The only guarantee is that -** the destructor will be called before the metadata is dropped. -** -** ^(In practice, metadata is preserved between function calls for -** expressions that are constant at compile time. This includes literal -** values and [parameters].)^ -** -** 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. See ticket #2191. -*/ -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 -** -** 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() interfaces set the result of -** the application-defined function to be a BLOB containing all zero -** bytes and N bytes in size, where N is the value of the 2nd parameter. -** -** ^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 in native -** byte order. ^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_toobig() interface causes SQLite to throw an error -** indicating that a string or BLOB is too long to represent. -** -** ^The sqlite3_result_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. -** ^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 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 -** from [sqlite3_malloc()] before it returns. -** -** ^The sqlite3_result_value() interface sets the result of -** the application-defined function to be a copy 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. -** -** 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_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_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_zeroblob(sqlite3_context*, int n); - -/* -** CAPI3REF: Define New Collating Sequences -** -** These functions are used to add new collation sequences to the -** [database connection] specified as the first argument. -** -** ^The name of the new collation sequence is specified as a UTF-8 string -** for sqlite3_create_collation() and sqlite3_create_collation_v2() -** and a UTF-16 string for sqlite3_create_collation16(). ^In all cases -** the name is passed as the second function argument. -** -** ^The third argument may be one of the constants [SQLITE_UTF8], -** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied -** routine expects to be passed pointers to strings encoded using UTF-8, -** UTF-16 little-endian, or UTF-16 big-endian, respectively. ^The -** third argument might also be [SQLITE_UTF16] to indicate that the routine -** expects pointers to be UTF-16 strings in the native byte order, or the -** argument can be [SQLITE_UTF16_ALIGNED] if the -** the routine expects pointers to 16-bit word aligned strings -** of UTF-16 in the native byte order. -** -** A pointer to the user supplied routine must be passed as the fifth -** argument. ^If it is NULL, this is the same as deleting the collation -** sequence (so that SQLite cannot call it anymore). -** ^Each time the application supplied function is invoked, it is passed -** as its first parameter a copy of the void* passed as the fourth argument -** to sqlite3_create_collation() or sqlite3_create_collation16(). -** -** ^The remaining arguments to the application-supplied routine are two strings, -** each represented by a (length, data) pair and encoded in the encoding -** that was passed as the third argument when the collation sequence was -** registered. The application defined collation routine should -** return negative, zero or positive if the first string is less than, -** equal to, or greater than the second string. i.e. (STRING1 - STRING2). -** -** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() -** except that it takes an extra argument which is a destructor for -** the collation. ^The destructor is called when the collation is -** destroyed and is passed a copy of the fourth parameter void* pointer -** of the sqlite3_create_collation_v2(). -** ^Collations are destroyed when they are overridden by later calls to the -** collation creation functions or when the [database connection] is closed -** using [sqlite3_close()]. -** -** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. -*/ -SQLITE_API int sqlite3_create_collation( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); -SQLITE_API int sqlite3_create_collation_v2( - sqlite3*, - const char *zName, - int eTextRep, - void*, - 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*, - int(*xCompare)(void*,int,const void*,int,const void*) -); - -/* -** CAPI3REF: Collation Needed Callbacks -** -** ^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*) -); - -#if SQLITE_HAS_CODEC -/* -** Specify the key for an encrypted database. This routine should be -** called right after sqlite3_open(). -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_key( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The key */ -); - -/* -** Change the key on an open database. If the current database is not -** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the -** database is decrypted. -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_rekey( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The new key */ -); - -/* -** Specify the activation key for a SEE database. Unless -** activated, none of the SEE routines will work. -*/ -SQLITE_API void sqlite3_activate_see( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -#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. -*/ -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. -** -** 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. -*/ -SQLITE_API char *sqlite3_temp_directory; - -/* -** CAPI3REF: Test For Auto-Commit Mode -** KEYWORDS: {autocommit mode} -** -** ^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 -** -** ^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: Find the next prepared statement -** -** ^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 -** -** ^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 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 [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** 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. -** ^The rollback callback is not invoked if a transaction is -** rolled back because a commit callback returned non-zero. -** -** 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 -** -** ^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. -** ^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. -** ^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_master and sqlite_sequence).)^ -** -** ^In the current implementation, the update hook -** is not invoked when duplication 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()] and [sqlite3_rollback_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 -** KEYWORDS: {shared 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. 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 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. But this might change in -** future releases of SQLite. Applications that care about shared -** cache setting should set it explicitly. -** -** 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. -*/ -SQLITE_API int sqlite3_release_memory(int); - -/* -** CAPI3REF: Impose A Limit On Heap Size -** -** ^The sqlite3_soft_heap_limit() interface places a "soft" limit -** on the amount of heap memory that may be allocated by SQLite. -** ^If an internal allocation is requested that would exceed the -** soft heap limit, [sqlite3_release_memory()] is invoked one or -** more times to free up some space before the allocation is performed. -** -** ^The limit is called "soft" because if [sqlite3_release_memory()] -** cannot free sufficient memory to prevent the limit from being exceeded, -** the memory is allocated anyway and the current operation proceeds. -** -** ^A negative or zero value for N means that there is no soft heap limit and -** [sqlite3_release_memory()] will only be called when memory is exhausted. -** ^The default value for the soft heap limit is zero. -** -** ^(SQLite makes a best effort to honor the soft heap limit. -** But if the soft heap limit cannot be honored, execution will -** continue without error or notification.)^ This is why the limit is -** called a "soft" limit. It is advisory only. -** -** Prior to SQLite version 3.5.0, this routine only constrained the memory -** allocated by a single thread - the same thread in which this routine -** runs. Beginning with SQLite version 3.5.0, the soft heap limit is -** applied to all threads. The value specified for the soft heap limit -** is an upper bound on the total memory allocation for all threads. In -** version 3.5.0 there is no mechanism for limiting the heap usage for -** individual threads. -*/ -SQLITE_API void sqlite3_soft_heap_limit(int); - -/* -** CAPI3REF: Extract Metadata About A Column Of A Table -** -** ^This routine returns metadata about a specific column of a specific -** database table accessible using the [database connection] handle -** passed as the first function argument. -** -** ^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. Neither of these parameters -** may be NULL. -** -** ^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 only 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 an -** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output -** parameters are set for the explicitly declared column. ^(If there is no -** explicitly declared [INTEGER PRIMARY KEY] column, then the output -** parameters are set as follows: -** -** 
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-**
)^ -** -** ^(This function may load one or more schemas from database files. If an -** error occurs during this process, or if the requested table or column -** cannot be found, an [error code] is returned and an error message left -** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ -** -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. -*/ -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 -** -** ^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. -** -** ^The entry point is zProc. -** ^zProc may be 0, in which case the name of the entry point -** defaults to "sqlite3_extension_init". -** ^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()] prior to calling this API, -** otherwise an error will be returned. -** -** 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 -** -** ^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. See ticket #1863. -** ^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. -*/ -SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); - -/* -** CAPI3REF: Automatically Load An Extensions -** -** ^This API can be invoked at program startup in order to register -** one or more statically linked extensions that will be available -** to all new [database connections]. -** -** ^(This routine stores a pointer to the extension entry point -** in an array that is obtained from [sqlite3_malloc()]. That memory -** is deallocated by [sqlite3_reset_auto_extension()].)^ -** -** ^This function registers an extension entry point that is -** automatically invoked whenever a new [database connection] -** is opened using [sqlite3_open()], [sqlite3_open16()], -** or [sqlite3_open_v2()]. -** ^Duplicate extensions are detected so calling this routine -** multiple times with the same extension is harmless. -** ^Automatic extensions apply across all threads. -*/ -SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); - -/* -** CAPI3REF: Reset Automatic Extension Loading -** -** ^(This function disables all previously registered automatic -** extensions. It undoes the effect of all prior -** [sqlite3_auto_extension()] calls.)^ -** -** ^This function disables automatic extensions in all threads. -*/ -SQLITE_API void sqlite3_reset_auto_extension(void); - -/* -****** EXPERIMENTAL - subject to change without notice ************** -** -** 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} -** EXPERIMENTAL -** -** This structure, sometimes called a a "virtual table module", -** defines the implementation of a [virtual tables]. -** 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); -}; - -/* -** CAPI3REF: Virtual Table Indexing Information -** KEYWORDS: sqlite3_index_info -** EXPERIMENTAL -** -** The sqlite3_index_info structure and its substructures is used 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.)^ ^(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 [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 is not checked again by SQLite.)^ -** -** ^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 doing the -** particular lookup. A full scan of a table with N entries should have -** a cost of N. A binary search of a table of N entries should have a -** cost of approximately log(N). -*/ -struct sqlite3_index_info { - /* Inputs */ - int nConstraint; /* Number of entries in aConstraint */ - struct sqlite3_index_constraint { - int iColumn; /* Column on left-hand side of constraint */ - 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 */ -}; -#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 - -/* -** CAPI3REF: Register A Virtual Table Implementation -** EXPERIMENTAL -** -** ^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 sqlite3_create_module() -** interface is equivalent to sqlite3_create_module_v2() with a NULL -** destructor. -*/ -SQLITE_API SQLITE_EXPERIMENTAL 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 SQLITE_EXPERIMENTAL 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: Virtual Table Instance Object -** KEYWORDS: sqlite3_vtab -** EXPERIMENTAL -** -** 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; /* NO LONGER USED */ - 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} -** EXPERIMENTAL -** -** 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 -** EXPERIMENTAL -** -** ^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 SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL); - -/* -** CAPI3REF: Overload A Function For A Virtual Table -** EXPERIMENTAL -** -** ^(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 SQLITE_EXPERIMENTAL 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. -** -****** EXPERIMENTAL - subject to change without notice ************** -*/ - -/* -** 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 -** -** ^(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;
-**
)^ -** -** ^If the flags parameter is non-zero, then the BLOB is opened for read -** and write access. ^If it is zero, the BLOB is opened for read access. -** ^It is not possible to open a column that is part of an index or primary -** key for writing. ^If [foreign key constraints] are enabled, it is -** not possible to open a column that is part of a [child key] for writing. -** -** ^Note that the database name is not the filename that contains -** the database but rather the symbolic name of the database that -** appears after the AS keyword when the database is connected using [ATTACH]. -** ^For the main database file, the database name is "main". -** ^For TEMP tables, the database name is "temp". -** -** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written -** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set -** to be a null pointer.)^ -** ^This function sets the [database connection] error code and message -** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related -** functions. ^Note that the *ppBlob variable is always initialized in a -** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob -** regardless of the success or failure of this routine. -** -** ^(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 -** a expired BLOB handle fail with an 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 can be used, if desired, -** to create an empty, zero-filled blob in which to read or write using -** this interface. -** -** To avoid a resource leak, every open [BLOB handle] should eventually -** be released by a call to [sqlite3_blob_close()]. -*/ -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: Close A BLOB Handle -** -** ^Closes an open [BLOB handle]. -** -** ^Closing a BLOB shall cause the current transaction to commit -** if there are no other BLOBs, no pending prepared statements, and the -** database connection is in [autocommit mode]. -** ^If any writes were made to the BLOB, they might be held in cache -** until the close operation if they will fit. -** -** ^(Closing the BLOB often forces the changes -** out to disk and so if any I/O errors occur, they will likely occur -** at the time when the BLOB is closed. Any errors that occur during -** closing are reported as a non-zero return value.)^ -** -** ^(The BLOB is closed unconditionally. Even if this routine returns -** an error code, the BLOB is still closed.)^ -** -** ^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. -*/ -SQLITE_API int sqlite3_blob_close(sqlite3_blob *); - -/* -** CAPI3REF: Return The Size Of An Open 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 -** -** ^(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 -** -** ^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. -** -** ^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. ^If N is -** less than zero [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. -** -** ^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. -** -** ^(On success, sqlite3_blob_write() 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_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_OS2 -**
  • SQLITE_MUTEX_PTHREAD -**
  • 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_OS2, -** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations -** are appropriate for use on OS/2, 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. ^If it returns NULL -** that means that a mutex could not be allocated. ^SQLite -** will unwind its stack and return an error. ^(The argument -** to sqlite3_mutex_alloc() is one of these integer constants: -** -**
    -**
  • SQLITE_MUTEX_FAST -**
  • SQLITE_MUTEX_RECURSIVE -**
  • SQLITE_MUTEX_STATIC_MASTER -**
  • SQLITE_MUTEX_STATIC_MEM -**
  • SQLITE_MUTEX_STATIC_MEM2 -**
  • SQLITE_MUTEX_STATIC_PRNG -**
  • SQLITE_MUTEX_STATIC_LRU -**
  • SQLITE_MUTEX_STATIC_LRU2 -**
)^ -** -** ^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. ^Six 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. ^But 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. ^SQLite is careful to deallocate every -** dynamic mutex that it allocates. The dynamic mutexes must not be in -** use when they are deallocated. Attempting to deallocate a static -** mutex results in undefined behavior. ^SQLite never deallocates -** a static mutex. -** -** ^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 other -** kind of mutex more than once, the behavior is undefined. -** SQLite will never exhibit -** such behavior in its own use of mutexes.)^ -** -** ^(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. SQLite will -** never do either.)^ -** -** ^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 -** EXPERIMENTAL -** -** 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 user 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 user -** 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 calle 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() mutiple 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 provided 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 -** 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_MASTER 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_random() */ -#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ -#define SQLITE_MUTEX_STATIC_LRU2 7 /* lru page list */ - -/* -** CAPI3REF: Retrieve the mutex for a database connection -** -** ^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 -** -** ^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 "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. -** -** ^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: [SQLITE_FCNTL_LOCKSTATE] -*/ -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 -#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 -#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 -#define SQLITE_TESTCTRL_ISKEYWORD 16 -#define SQLITE_TESTCTRL_LAST 16 - -/* -** CAPI3REF: SQLite Runtime Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about the preformance 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 [SQLITE_STATUS_MEMORY_USED | 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_db_status() routine returns SQLITE_OK on success and a -** non-zero [error code] on failure. -** -** This routine is threadsafe but is not atomic. This routine can be -** called while other threads are running the same or different SQLite -** interfaces. However the values returned in *pCurrent and -** *pHighwater reflect the status of SQLite at different points in time -** and it is possible that another thread might change the parameter -** in between the times when *pCurrent and *pHighwater are written. -** -** See also: [sqlite3_db_status()] -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); - - -/* -** CAPI3REF: Status Parameters -** EXPERIMENTAL -** -** These integer constants designate various run-time status parameters -** that can be returned by [sqlite3_status()]. -** -**
-** ^(
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. Scratch memory -** controlled by [SQLITE_CONFIG_SCRATCH] and 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
-**
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_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
-**
This parameter returns the number of bytes of page cache -** allocation which could not be statisfied 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
-**
This parameter records the largest memory allocation request -** handed to [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
-**
This parameter returns the number of allocations used out of the -** [scratch memory allocator] configured using -** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not -** in bytes. Since a single thread may only have one scratch allocation -** outstanding at time, this parameter also reports the number of threads -** using scratch memory at the same time.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
-**
This parameter returns the number of bytes of scratch memory -** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH] -** buffer and where forced to overflow to [sqlite3_malloc()]. The values -** returned include overflows because the requested allocation was too -** larger (that is, because the requested allocation was larger than the -** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer -** slots were available. -**
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_SIZE
-**
This parameter records the largest memory allocation request -** handed to [scratch 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_PARSER_STACK
-**
This parameter records the deepest parser stack. It 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 -#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 -#define SQLITE_STATUS_MALLOC_SIZE 5 -#define SQLITE_STATUS_PARSER_STACK 6 -#define SQLITE_STATUS_PAGECACHE_SIZE 7 -#define SQLITE_STATUS_SCRATCH_SIZE 8 - -/* -** CAPI3REF: Database Connection Status -** EXPERIMENTAL -** -** ^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 the parameter to interrogate. ^Currently, the only allowed value -** for the second parameter is [SQLITE_DBSTATUS_LOOKASIDE_USED]. -** Additional options will likely appear 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. -** -** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); - -/* -** CAPI3REF: Status Parameters for database connections -** EXPERIMENTAL -** -** 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
-**
This parameter returns the number of lookaside memory slots currently -** checked out.
)^ -**
-*/ -#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 - - -/* -** CAPI3REF: Prepared Statement Status -** EXPERIMENTAL -** -** ^(Each prepared statement maintains various -** [SQLITE_STMTSTATUS_SORT | 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_SORT | 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 SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); - -/* -** CAPI3REF: Status Parameters for prepared statements -** EXPERIMENTAL -** -** 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
-**
^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
-**
^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.
-** -**
-*/ -#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 -#define SQLITE_STMTSTATUS_SORT 2 - -/* -** CAPI3REF: Custom Page Cache Object -** EXPERIMENTAL -** -** 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_methods] for additional information. -*/ -typedef struct sqlite3_pcache sqlite3_pcache; - -/* -** CAPI3REF: Application Defined Page Cache. -** KEYWORDS: {page cache} -** EXPERIMENTAL -** -** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can -** register an alternative page cache implementation by passing in an -** instance of the sqlite3_pcache_methods structure.)^ The majority of the -** heap memory used by SQLite is used by the page cache to cache data read -** from, or ready to be written to, the database file. By implementing a -** custom page cache using this API, an application can control more -** precisely 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 contents of the sqlite3_pcache_methods 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() method is called once for each call to [sqlite3_initialize()] -** (usually only once during the lifetime of the process). ^(The xInit() -** method is passed a copy of the sqlite3_pcache_methods.pArg value.)^ -** ^The xInit() method can set up up global structures and/or any mutexes -** required by the custom page cache implementation. -** -** ^The xShutdown() method is called from within [sqlite3_shutdown()], -** if the application invokes this API. It can be used to clean up -** any outstanding resources before process shutdown, if required. -** -** ^SQLite holds a [SQLITE_MUTEX_RECURSIVE] 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. 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() method is used 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 not be a power of two. ^szPage -** will the page size of the database file that is to be cached plus an -** increment (here called "R") of about 100 or 200. ^SQLite will use the -** extra R bytes on each page to store metadata about the underlying -** database page on disk. The value of R depends -** on the SQLite version, the target platform, and how SQLite was compiled. -** ^R is constant for a particular build of SQLite. ^The second 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, a cache created with bPurgeable set to false will -** never contain any unpinned pages. -** -** ^(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() method should return the number of pages currently -** stored in the cache. -** -** ^The xFetch() method is used to fetch a page and return a pointer to it. -** ^A 'page', in this context, is a buffer of szPage bytes aligned at an -** 8-byte boundary. ^The page to be fetched is determined by the key. ^The -** mimimum 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 -** behavior of the cache implementation is determined by the value of the -** createFlag parameter passed to xFetch, according to the following table: -** -** -**
createFlag Behaviour 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. If -** a call to xFetch() with createFlag==1 returns NULL, then SQLite will -** attempt to unpin one or more cache pages by spilling the content of -** pinned pages to disk and synching the operating system disk cache. After -** attempting to unpin pages, the xFetch() method will be invoked again with -** a createFlag of 2. -** -** ^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 should be evicted from the cache. In this case SQLite -** assumes that the next time the page is retrieved from the cache using -** the xFetch() method, it will be zeroed.)^ ^If the discard parameter is -** zero, then the page is considered to be unpinned. ^The cache implementation -** may choose to evict unpinned pages at any time. -** -** ^(The cache is not required to perform any reference counting. A single -** call to xUnpin() unpins the page regardless of the number of prior calls -** to xFetch().)^ -** -** ^The xRekey() method is used to change the key value associated with the -** page passed as the second argument from oldKey to newKey. ^If the cache -** previously contains an entry associated with newKey, it should 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() 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_methods -** functions. -*/ -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 -** EXPERIMENTAL -** -** 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. -** EXPERIMENTAL -** -** 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] -** -** ^Exclusive access is required to the destination database for the -** duration of the operation. ^However the source database is only -** read-locked while it is actually 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 users 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() -** -** ^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 file with -** an error. -** -** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is -** returned and an error code and error message are store3d 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() -** -** ^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 resturns [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 the destination -** database was opened read-only or if -** the destination is an in-memory database with a different page size -** from the source database. -** -** ^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() -** -** 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() -** -** ^Each call to sqlite3_backup_step() sets two values inside -** the [sqlite3_backup] object: the number of pages still to be backed -** up and the total number of pages in the source databae file. -** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces -** retrieve these two values, respectively. -** -** ^The values returned by these functions are only updated by -** sqlite3_backup_step(). ^If the source database is modified during a backup -** operation, then the values are not updated to account for any extra -** pages that need to be updated or the size of the source database file -** changing. -** -** 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 -** EXPERIMENTAL -** -** ^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 connections 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 cancelled. ^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 connections 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 -** EXPERIMENTAL -** -** ^The [sqlite3_strnicmp()] API allows applications and extensions to -** compare the contents of two buffers containing UTF-8 strings in a -** case-indendent fashion, using the same definition of case independence -** that SQLite uses internally when comparing identifiers. -*/ -SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); - -/* -** CAPI3REF: Error Logging Interface -** EXPERIMENTAL -** -** ^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 -** passed through to [sqlite3_vmprintf()] 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, ...); - -/* -** 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 - -#if 0 -} /* End of the 'extern "C"' block */ -#endif -#endif - - -/************** End of sqlite3.h *********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include hash.h in the middle of sqliteInt.h ******************/ -/************** Begin file hash.h ********************************************/ -/* -** 2001 September 22 -** -** 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 is the header file for the generic hash-table implemenation -** used in SQLite. -*/ -#ifndef _SQLITE_HASH_H_ -#define _SQLITE_HASH_H_ - -/* Forward declarations of structures. */ -typedef struct Hash Hash; -typedef struct HashElem HashElem; - -/* A complete hash table is an instance of the following structure. -** The internals of this structure are intended to be opaque -- client -** code should not attempt to access or modify the fields of this structure -** directly. Change this structure only by using the routines below. -** However, some of the "procedures" and "functions" for modifying and -** accessing this structure are really macros, so we can't really make -** this structure opaque. -** -** All elements of the hash table are on a single doubly-linked list. -** Hash.first points to the head of this list. -** -** There are Hash.htsize buckets. Each bucket points to a spot in -** the global doubly-linked list. The contents of the bucket are the -** element pointed to plus the next _ht.count-1 elements in the list. -** -** Hash.htsize and Hash.ht may be zero. In that case lookup is done -** by a linear search of the global list. For small tables, the -** Hash.ht table is never allocated because if there are few elements -** in the table, it is faster to do a linear search than to manage -** the hash table. -*/ -struct Hash { - unsigned int htsize; /* Number of buckets in the hash table */ - unsigned int count; /* Number of entries in this table */ - HashElem *first; /* The first element of the array */ - struct _ht { /* the hash table */ - int count; /* Number of entries with this hash */ - HashElem *chain; /* Pointer to first entry with this hash */ - } *ht; -}; - -/* Each element in the hash table is an instance of the following -** structure. All elements are stored on a single doubly-linked list. -** -** Again, this structure is intended to be opaque, but it can't really -** be opaque because it is used by macros. -*/ -struct HashElem { - HashElem *next, *prev; /* Next and previous elements in the table */ - void *data; /* Data associated with this element */ - const char *pKey; int nKey; /* Key associated with this element */ -}; - -/* -** Access routines. To delete, insert a NULL pointer. -*/ -SQLITE_PRIVATE void sqlite3HashInit(Hash*); -SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData); -SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey); -SQLITE_PRIVATE void sqlite3HashClear(Hash*); - -/* -** Macros for looping over all elements of a hash table. The idiom is -** like this: -** -** Hash h; -** HashElem *p; -** ... -** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ -** SomeStructure *pData = sqliteHashData(p); -** // do something with pData -** } -*/ -#define sqliteHashFirst(H) ((H)->first) -#define sqliteHashNext(E) ((E)->next) -#define sqliteHashData(E) ((E)->data) -/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ -/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ - -/* -** Number of entries in a hash table -*/ -/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ - -#endif /* _SQLITE_HASH_H_ */ - -/************** End of hash.h ************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include parse.h in the middle of sqliteInt.h *****************/ -/************** Begin file parse.h *******************************************/ -#define TK_SEMI 1 -#define TK_EXPLAIN 2 -#define TK_QUERY 3 -#define TK_PLAN 4 -#define TK_BEGIN 5 -#define TK_TRANSACTION 6 -#define TK_DEFERRED 7 -#define TK_IMMEDIATE 8 -#define TK_EXCLUSIVE 9 -#define TK_COMMIT 10 -#define TK_END 11 -#define TK_ROLLBACK 12 -#define TK_SAVEPOINT 13 -#define TK_RELEASE 14 -#define TK_TO 15 -#define TK_TABLE 16 -#define TK_CREATE 17 -#define TK_IF 18 -#define TK_NOT 19 -#define TK_EXISTS 20 -#define TK_TEMP 21 -#define TK_LP 22 -#define TK_RP 23 -#define TK_AS 24 -#define TK_COMMA 25 -#define TK_ID 26 -#define TK_INDEXED 27 -#define TK_ABORT 28 -#define TK_ACTION 29 -#define TK_AFTER 30 -#define TK_ANALYZE 31 -#define TK_ASC 32 -#define TK_ATTACH 33 -#define TK_BEFORE 34 -#define TK_BY 35 -#define TK_CASCADE 36 -#define TK_CAST 37 -#define TK_COLUMNKW 38 -#define TK_CONFLICT 39 -#define TK_DATABASE 40 -#define TK_DESC 41 -#define TK_DETACH 42 -#define TK_EACH 43 -#define TK_FAIL 44 -#define TK_FOR 45 -#define TK_IGNORE 46 -#define TK_INITIALLY 47 -#define TK_INSTEAD 48 -#define TK_LIKE_KW 49 -#define TK_MATCH 50 -#define TK_NO 51 -#define TK_KEY 52 -#define TK_OF 53 -#define TK_OFFSET 54 -#define TK_PRAGMA 55 -#define TK_RAISE 56 -#define TK_REPLACE 57 -#define TK_RESTRICT 58 -#define TK_ROW 59 -#define TK_TRIGGER 60 -#define TK_VACUUM 61 -#define TK_VIEW 62 -#define TK_VIRTUAL 63 -#define TK_REINDEX 64 -#define TK_RENAME 65 -#define TK_CTIME_KW 66 -#define TK_ANY 67 -#define TK_OR 68 -#define TK_AND 69 -#define TK_IS 70 -#define TK_BETWEEN 71 -#define TK_IN 72 -#define TK_ISNULL 73 -#define TK_NOTNULL 74 -#define TK_NE 75 -#define TK_EQ 76 -#define TK_GT 77 -#define TK_LE 78 -#define TK_LT 79 -#define TK_GE 80 -#define TK_ESCAPE 81 -#define TK_BITAND 82 -#define TK_BITOR 83 -#define TK_LSHIFT 84 -#define TK_RSHIFT 85 -#define TK_PLUS 86 -#define TK_MINUS 87 -#define TK_STAR 88 -#define TK_SLASH 89 -#define TK_REM 90 -#define TK_CONCAT 91 -#define TK_COLLATE 92 -#define TK_BITNOT 93 -#define TK_STRING 94 -#define TK_JOIN_KW 95 -#define TK_CONSTRAINT 96 -#define TK_DEFAULT 97 -#define TK_NULL 98 -#define TK_PRIMARY 99 -#define TK_UNIQUE 100 -#define TK_CHECK 101 -#define TK_REFERENCES 102 -#define TK_AUTOINCR 103 -#define TK_ON 104 -#define TK_INSERT 105 -#define TK_DELETE 106 -#define TK_UPDATE 107 -#define TK_SET 108 -#define TK_DEFERRABLE 109 -#define TK_FOREIGN 110 -#define TK_DROP 111 -#define TK_UNION 112 -#define TK_ALL 113 -#define TK_EXCEPT 114 -#define TK_INTERSECT 115 -#define TK_SELECT 116 -#define TK_DISTINCT 117 -#define TK_DOT 118 -#define TK_FROM 119 -#define TK_JOIN 120 -#define TK_USING 121 -#define TK_ORDER 122 -#define TK_GROUP 123 -#define TK_HAVING 124 -#define TK_LIMIT 125 -#define TK_WHERE 126 -#define TK_INTO 127 -#define TK_VALUES 128 -#define TK_INTEGER 129 -#define TK_FLOAT 130 -#define TK_BLOB 131 -#define TK_REGISTER 132 -#define TK_VARIABLE 133 -#define TK_CASE 134 -#define TK_WHEN 135 -#define TK_THEN 136 -#define TK_ELSE 137 -#define TK_INDEX 138 -#define TK_ALTER 139 -#define TK_ADD 140 -#define TK_TO_TEXT 141 -#define TK_TO_BLOB 142 -#define TK_TO_NUMERIC 143 -#define TK_TO_INT 144 -#define TK_TO_REAL 145 -#define TK_ISNOT 146 -#define TK_END_OF_FILE 147 -#define TK_ILLEGAL 148 -#define TK_SPACE 149 -#define TK_UNCLOSED_STRING 150 -#define TK_FUNCTION 151 -#define TK_COLUMN 152 -#define TK_AGG_FUNCTION 153 -#define TK_AGG_COLUMN 154 -#define TK_CONST_FUNC 155 -#define TK_UMINUS 156 -#define TK_UPLUS 157 - -/************** End of parse.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -#include -#include -#include -#include -#include - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite_int64 -# define LONGDOUBLE_TYPE sqlite_int64 -# ifndef SQLITE_BIG_DBL -# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) -# endif -# define SQLITE_OMIT_DATETIME_FUNCS 1 -# define SQLITE_OMIT_TRACE 1 -# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT -# undef SQLITE_HAVE_ISNAN -#endif -#ifndef SQLITE_BIG_DBL -# define SQLITE_BIG_DBL (1e99) -#endif - -/* -** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 -** afterward. Having this macro allows us to cause the C compiler -** to omit code used by TEMP tables without messy #ifndef statements. -*/ -#ifdef SQLITE_OMIT_TEMPDB -#define OMIT_TEMPDB 1 -#else -#define OMIT_TEMPDB 0 -#endif - -/* -** The "file format" number is an integer that is incremented whenever -** the VDBE-level file format changes. The following macros define the -** the default file format for new databases and the maximum file format -** that the library can read. -*/ -#define SQLITE_MAX_FILE_FORMAT 4 -#ifndef SQLITE_DEFAULT_FILE_FORMAT -# define SQLITE_DEFAULT_FILE_FORMAT 1 -#endif - -/* -** Determine whether triggers are recursive by default. This can be -** changed at run-time using a pragma. -*/ -#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS -# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 -#endif - -/* -** Provide a default value for SQLITE_TEMP_STORE in case it is not specified -** on the command-line -*/ -#ifndef SQLITE_TEMP_STORE -# define SQLITE_TEMP_STORE 1 -#endif - -/* -** GCC does not define the offsetof() macro so we'll have to do it -** ourselves. -*/ -#ifndef offsetof -#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) -#endif - -/* -** Check to see if this machine uses EBCDIC. (Yes, believe it or -** not, there are still machines out there that use EBCDIC.) -*/ -#if 'A' == '\301' -# define SQLITE_EBCDIC 1 -#else -# define SQLITE_ASCII 1 -#endif - -/* -** Integers of known sizes. These typedefs might change for architectures -** where the sizes very. Preprocessor macros are available so that the -** types can be conveniently redefined at compile-type. Like this: -** -** cc '-DUINTPTR_TYPE=long long int' ... -*/ -#ifndef UINT32_TYPE -# ifdef HAVE_UINT32_T -# define UINT32_TYPE uint32_t -# else -# define UINT32_TYPE unsigned int -# endif -#endif -#ifndef UINT16_TYPE -# ifdef HAVE_UINT16_T -# define UINT16_TYPE uint16_t -# else -# define UINT16_TYPE unsigned short int -# endif -#endif -#ifndef INT16_TYPE -# ifdef HAVE_INT16_T -# define INT16_TYPE int16_t -# else -# define INT16_TYPE short int -# endif -#endif -#ifndef UINT8_TYPE -# ifdef HAVE_UINT8_T -# define UINT8_TYPE uint8_t -# else -# define UINT8_TYPE unsigned char -# endif -#endif -#ifndef INT8_TYPE -# ifdef HAVE_INT8_T -# define INT8_TYPE int8_t -# else -# define INT8_TYPE signed char -# endif -#endif -#ifndef LONGDOUBLE_TYPE -# define LONGDOUBLE_TYPE long double -#endif -typedef sqlite_int64 i64; /* 8-byte signed integer */ -typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ -typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ -typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ -typedef INT16_TYPE i16; /* 2-byte signed integer */ -typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ -typedef INT8_TYPE i8; /* 1-byte signed integer */ - -/* -** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value -** that can be stored in a u32 without loss of data. The value -** is 0x00000000ffffffff. But because of quirks of some compilers, we -** have to specify the value in the less intuitive manner shown: -*/ -#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) - -/* -** Macros to determine whether the machine is big or little endian, -** evaluated at runtime. -*/ -#ifdef SQLITE_AMALGAMATION -SQLITE_PRIVATE const int sqlite3one = 1; -#else -SQLITE_PRIVATE const int sqlite3one; -#endif -#if defined(i386) || defined(__i386__) || defined(_M_IX86)\ - || defined(__x86_64) || defined(__x86_64__) -# define SQLITE_BIGENDIAN 0 -# define SQLITE_LITTLEENDIAN 1 -# define SQLITE_UTF16NATIVE SQLITE_UTF16LE -#else -# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) -# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) -# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) -#endif - -/* -** Constants for the largest and smallest possible 64-bit signed integers. -** These macros are designed to work correctly on both 32-bit and 64-bit -** compilers. -*/ -#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) -#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) - -/* -** Round up a number to the next larger multiple of 8. This is used -** to force 8-byte alignment on 64-bit architectures. -*/ -#define ROUND8(x) (((x)+7)&~7) - -/* -** Round down to the nearest multiple of 8 -*/ -#define ROUNDDOWN8(x) ((x)&~7) - -/* -** Assert that the pointer X is aligned to an 8-byte boundary. This -** macro is used only within assert() to verify that the code gets -** all alignment restrictions correct. -** -** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the -** underlying malloc() implemention might return us 4-byte aligned -** pointers. In that case, only verify 4-byte alignment. -*/ -#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC -# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) -#else -# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) -#endif - - -/* -** An instance of the following structure is used to store the busy-handler -** callback for a given sqlite handle. -** -** The sqlite.busyHandler member of the sqlite struct contains the busy -** callback for the database handle. Each pager opened via the sqlite -** handle is passed a pointer to sqlite.busyHandler. The busy-handler -** callback is currently invoked only from within pager.c. -*/ -typedef struct BusyHandler BusyHandler; -struct BusyHandler { - int (*xFunc)(void *,int); /* The busy callback */ - void *pArg; /* First arg to busy callback */ - int nBusy; /* Incremented with each busy call */ -}; - -/* -** Name of the master database table. The master database table -** is a special table that holds the names and attributes of all -** user tables and indices. -*/ -#define MASTER_NAME "sqlite_master" -#define TEMP_MASTER_NAME "sqlite_temp_master" - -/* -** The root-page of the master database table. -*/ -#define MASTER_ROOT 1 - -/* -** The name of the schema table. -*/ -#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) - -/* -** A convenience macro that returns the number of elements in -** an array. -*/ -#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) - -/* -** The following value as a destructor means to use sqlite3DbFree(). -** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT. -*/ -#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree) - -/* -** When SQLITE_OMIT_WSD is defined, it means that the target platform does -** not support Writable Static Data (WSD) such as global and static variables. -** All variables must either be on the stack or dynamically allocated from -** the heap. When WSD is unsupported, the variable declarations scattered -** throughout the SQLite code must become constants instead. The SQLITE_WSD -** macro is used for this purpose. And instead of referencing the variable -** directly, we use its constant as a key to lookup the run-time allocated -** buffer that holds real variable. The constant is also the initializer -** for the run-time allocated buffer. -** -** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL -** macros become no-ops and have zero performance impact. -*/ -#ifdef SQLITE_OMIT_WSD - #define SQLITE_WSD const - #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) - #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) -SQLITE_API int sqlite3_wsd_init(int N, int J); -SQLITE_API void *sqlite3_wsd_find(void *K, int L); -#else - #define SQLITE_WSD - #define GLOBAL(t,v) v - #define sqlite3GlobalConfig sqlite3Config -#endif - -/* -** The following macros are used to suppress compiler warnings and to -** make it clear to human readers when a function parameter is deliberately -** left unused within the body of a function. This usually happens when -** a function is called via a function pointer. For example the -** implementation of an SQL aggregate step callback may not use the -** parameter indicating the number of arguments passed to the aggregate, -** if it knows that this is enforced elsewhere. -** -** When a function parameter is not used at all within the body of a function, -** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. -** However, these macros may also be used to suppress warnings related to -** parameters that may or may not be used depending on compilation options. -** For example those parameters only used in assert() statements. In these -** cases the parameters are named as per the usual conventions. -*/ -#define UNUSED_PARAMETER(x) (void)(x) -#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) - -/* -** Forward references to structures -*/ -typedef struct AggInfo AggInfo; -typedef struct AuthContext AuthContext; -typedef struct AutoincInfo AutoincInfo; -typedef struct Bitvec Bitvec; -typedef struct CollSeq CollSeq; -typedef struct Column Column; -typedef struct Db Db; -typedef struct Schema Schema; -typedef struct Expr Expr; -typedef struct ExprList ExprList; -typedef struct ExprSpan ExprSpan; -typedef struct FKey FKey; -typedef struct FuncDef FuncDef; -typedef struct FuncDefHash FuncDefHash; -typedef struct IdList IdList; -typedef struct Index Index; -typedef struct IndexSample IndexSample; -typedef struct KeyClass KeyClass; -typedef struct KeyInfo KeyInfo; -typedef struct Lookaside Lookaside; -typedef struct LookasideSlot LookasideSlot; -typedef struct Module Module; -typedef struct NameContext NameContext; -typedef struct Parse Parse; -typedef struct RowSet RowSet; -typedef struct Savepoint Savepoint; -typedef struct Select Select; -typedef struct SrcList SrcList; -typedef struct StrAccum StrAccum; -typedef struct Table Table; -typedef struct TableLock TableLock; -typedef struct Token Token; -typedef struct Trigger Trigger; -typedef struct TriggerPrg TriggerPrg; -typedef struct TriggerStep TriggerStep; -typedef struct UnpackedRecord UnpackedRecord; -typedef struct VTable VTable; -typedef struct Walker Walker; -typedef struct WherePlan WherePlan; -typedef struct WhereInfo WhereInfo; -typedef struct WhereLevel WhereLevel; - -/* -** Defer sourcing vdbe.h and btree.h until after the "u8" and -** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque -** pointer types (i.e. FuncDef) defined above. -*/ -/************** Include btree.h in the middle of sqliteInt.h *****************/ -/************** Begin file btree.h *******************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the sqlite B-Tree file -** subsystem. See comments in the source code for a detailed description -** of what each interface routine does. -*/ -#ifndef _BTREE_H_ -#define _BTREE_H_ - -/* TODO: This definition is just included so other modules compile. It -** needs to be revisited. -*/ -#define SQLITE_N_BTREE_META 10 - -/* -** If defined as non-zero, auto-vacuum is enabled by default. Otherwise -** it must be turned on for each database using "PRAGMA auto_vacuum = 1". -*/ -#ifndef SQLITE_DEFAULT_AUTOVACUUM - #define SQLITE_DEFAULT_AUTOVACUUM 0 -#endif - -#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ -#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ -#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ - -/* -** Forward declarations of structure -*/ -typedef struct Btree Btree; -typedef struct BtCursor BtCursor; -typedef struct BtShared BtShared; -typedef struct BtreeMutexArray BtreeMutexArray; - -/* -** This structure records all of the Btrees that need to hold -** a mutex before we enter sqlite3VdbeExec(). The Btrees are -** are placed in aBtree[] in order of aBtree[]->pBt. That way, -** we can always lock and unlock them all quickly. -*/ -struct BtreeMutexArray { - int nMutex; - Btree *aBtree[SQLITE_MAX_ATTACHED+1]; -}; - - -SQLITE_PRIVATE int sqlite3BtreeOpen( - const char *zFilename, /* Name of database file to open */ - sqlite3 *db, /* Associated database connection */ - Btree **ppBtree, /* Return open Btree* here */ - int flags, /* Flags */ - int vfsFlags /* Flags passed through to VFS open */ -); - -/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the -** following values. -** -** NOTE: These values must match the corresponding PAGER_ values in -** pager.h. -*/ -#define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */ -#define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */ -#define BTREE_MEMORY 4 /* In-memory DB. No argument */ -#define BTREE_READONLY 8 /* Open the database in read-only mode */ -#define BTREE_READWRITE 16 /* Open for both reading and writing */ -#define BTREE_CREATE 32 /* Create the database if it does not exist */ - -SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int); -SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); -SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); -SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); -SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); -SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); -SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*); -SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); -SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*); -SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags); -SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*); -SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*); -SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); -SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); -SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); -SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); -SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); - -SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); -SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); -SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); - -SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); - -/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR -** of the following flags: -*/ -#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ -#define BTREE_ZERODATA 2 /* Table has keys only - no data */ -#define BTREE_LEAFDATA 4 /* Data stored in leaves only. Implies INTKEY */ - -SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); -SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); -SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int); - -SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); -SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); - -/* -** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta -** should be one of the following values. The integer values are assigned -** to constants so that the offset of the corresponding field in an -** SQLite database header may be found using the following formula: -** -** offset = 36 + (idx * 4) -** -** For example, the free-page-count field is located at byte offset 36 of -** the database file header. The incr-vacuum-flag field is located at -** byte offset 64 (== 36+4*7). -*/ -#define BTREE_FREE_PAGE_COUNT 0 -#define BTREE_SCHEMA_VERSION 1 -#define BTREE_FILE_FORMAT 2 -#define BTREE_DEFAULT_CACHE_SIZE 3 -#define BTREE_LARGEST_ROOT_PAGE 4 -#define BTREE_TEXT_ENCODING 5 -#define BTREE_USER_VERSION 6 -#define BTREE_INCR_VACUUM 7 - -SQLITE_PRIVATE int sqlite3BtreeCursor( - Btree*, /* BTree containing table to open */ - int iTable, /* Index of root page */ - int wrFlag, /* 1 for writing. 0 for read-only */ - struct KeyInfo*, /* First argument to compare function */ - BtCursor *pCursor /* Space to write cursor structure */ -); -SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); -SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); - -SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( - BtCursor*, - UnpackedRecord *pUnKey, - i64 intKey, - int bias, - int *pRes -); -SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*, int*); -SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, - const void *pData, int nData, - int nZero, int bias, int seekResult); -SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); -SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); -SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); -SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); -SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64); -SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*); - -SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); -SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); - -SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *); -SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); - -#ifndef NDEBUG -SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); -#endif - -#ifndef SQLITE_OMIT_BTREECOUNT -SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *); -#endif - -#ifdef SQLITE_TEST -SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); -SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); -#endif - -/* -** If we are not using shared cache, then there is no need to -** use mutexes to access the BtShared structures. So make the -** Enter and Leave procedures no-ops. -*/ -#ifndef SQLITE_OMIT_SHARED_CACHE -SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); -SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); -#else -# define sqlite3BtreeEnter(X) -# define sqlite3BtreeEnterAll(X) -#endif - -#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE -SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); -SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); -SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); -SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*); -#ifndef NDEBUG - /* These routines are used inside assert() statements only. */ -SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); -SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); -#endif -#else - -# define sqlite3BtreeLeave(X) -# define sqlite3BtreeEnterCursor(X) -# define sqlite3BtreeLeaveCursor(X) -# define sqlite3BtreeLeaveAll(X) -# define sqlite3BtreeMutexArrayEnter(X) -# define sqlite3BtreeMutexArrayLeave(X) -# define sqlite3BtreeMutexArrayInsert(X,Y) - -# define sqlite3BtreeHoldsMutex(X) 1 -# define sqlite3BtreeHoldsAllMutexes(X) 1 -#endif - - -#endif /* _BTREE_H_ */ - -/************** End of btree.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include vdbe.h in the middle of sqliteInt.h ******************/ -/************** Begin file vdbe.h ********************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** Header file for the Virtual DataBase Engine (VDBE) -** -** This header defines the interface to the virtual database engine -** or VDBE. The VDBE implements an abstract machine that runs a -** simple program to access and modify the underlying database. -*/ -#ifndef _SQLITE_VDBE_H_ -#define _SQLITE_VDBE_H_ - -/* -** A single VDBE is an opaque structure named "Vdbe". Only routines -** in the source file sqliteVdbe.c are allowed to see the insides -** of this structure. -*/ -typedef struct Vdbe Vdbe; - -/* -** The names of the following types declared in vdbeInt.h are required -** for the VdbeOp definition. -*/ -typedef struct VdbeFunc VdbeFunc; -typedef struct Mem Mem; -typedef struct SubProgram SubProgram; - -/* -** A single instruction of the virtual machine has an opcode -** and as many as three operands. The instruction is recorded -** as an instance of the following structure: -*/ -struct VdbeOp { - u8 opcode; /* What operation to perform */ - signed char p4type; /* One of the P4_xxx constants for p4 */ - u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */ - u8 p5; /* Fifth parameter is an unsigned character */ - int p1; /* First operand */ - int p2; /* Second parameter (often the jump destination) */ - int p3; /* The third parameter */ - union { /* fourth parameter */ - int i; /* Integer value if p4type==P4_INT32 */ - void *p; /* Generic pointer */ - char *z; /* Pointer to data for string (char array) types */ - i64 *pI64; /* Used when p4type is P4_INT64 */ - double *pReal; /* Used when p4type is P4_REAL */ - FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ - VdbeFunc *pVdbeFunc; /* Used when p4type is P4_VDBEFUNC */ - CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ - Mem *pMem; /* Used when p4type is P4_MEM */ - VTable *pVtab; /* Used when p4type is P4_VTAB */ - KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ - int *ai; /* Used when p4type is P4_INTARRAY */ - SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ - } p4; -#ifdef SQLITE_DEBUG - char *zComment; /* Comment to improve readability */ -#endif -#ifdef VDBE_PROFILE - int cnt; /* Number of times this instruction was executed */ - u64 cycles; /* Total time spent executing this instruction */ -#endif -}; -typedef struct VdbeOp VdbeOp; - - -/* -** A sub-routine used to implement a trigger program. -*/ -struct SubProgram { - VdbeOp *aOp; /* Array of opcodes for sub-program */ - int nOp; /* Elements in aOp[] */ - int nMem; /* Number of memory cells required */ - int nCsr; /* Number of cursors required */ - int nRef; /* Number of pointers to this structure */ - void *token; /* id that may be used to recursive triggers */ -}; - -/* -** A smaller version of VdbeOp used for the VdbeAddOpList() function because -** it takes up less space. -*/ -struct VdbeOpList { - u8 opcode; /* What operation to perform */ - signed char p1; /* First operand */ - signed char p2; /* Second parameter (often the jump destination) */ - signed char p3; /* Third parameter */ -}; -typedef struct VdbeOpList VdbeOpList; - -/* -** Allowed values of VdbeOp.p4type -*/ -#define P4_NOTUSED 0 /* The P4 parameter is not used */ -#define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */ -#define P4_STATIC (-2) /* Pointer to a static string */ -#define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */ -#define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */ -#define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */ -#define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */ -#define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */ -#define P4_TRANSIENT (-9) /* P4 is a pointer to a transient string */ -#define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */ -#define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */ -#define P4_REAL (-12) /* P4 is a 64-bit floating point value */ -#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */ -#define P4_INT32 (-14) /* P4 is a 32-bit signed integer */ -#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */ -#define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */ - -/* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure -** is made. That copy is freed when the Vdbe is finalized. But if the -** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used. It still -** gets freed when the Vdbe is finalized so it still should be obtained -** from a single sqliteMalloc(). But no copy is made and the calling -** function should *not* try to free the KeyInfo. -*/ -#define P4_KEYINFO_HANDOFF (-16) -#define P4_KEYINFO_STATIC (-17) - -/* -** The Vdbe.aColName array contains 5n Mem structures, where n is the -** number of columns of data returned by the statement. -*/ -#define COLNAME_NAME 0 -#define COLNAME_DECLTYPE 1 -#define COLNAME_DATABASE 2 -#define COLNAME_TABLE 3 -#define COLNAME_COLUMN 4 -#ifdef SQLITE_ENABLE_COLUMN_METADATA -# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ -#else -# ifdef SQLITE_OMIT_DECLTYPE -# define COLNAME_N 1 /* Store only the name */ -# else -# define COLNAME_N 2 /* Store the name and decltype */ -# endif -#endif - -/* -** The following macro converts a relative address in the p2 field -** of a VdbeOp structure into a negative number so that -** sqlite3VdbeAddOpList() knows that the address is relative. Calling -** the macro again restores the address. -*/ -#define ADDR(X) (-1-(X)) - -/* -** The makefile scans the vdbe.c source file and creates the "opcodes.h" -** header file that defines a number for each opcode used by the VDBE. -*/ -/************** Include opcodes.h in the middle of vdbe.h ********************/ -/************** Begin file opcodes.h *****************************************/ -/* Automatically generated. Do not edit */ -/* See the mkopcodeh.awk script for details */ -#define OP_Goto 1 -#define OP_Gosub 2 -#define OP_Return 3 -#define OP_Yield 4 -#define OP_HaltIfNull 5 -#define OP_Halt 6 -#define OP_Integer 7 -#define OP_Int64 8 -#define OP_Real 130 /* same as TK_FLOAT */ -#define OP_String8 94 /* same as TK_STRING */ -#define OP_String 9 -#define OP_Null 10 -#define OP_Blob 11 -#define OP_Variable 12 -#define OP_Move 13 -#define OP_Copy 14 -#define OP_SCopy 15 -#define OP_ResultRow 16 -#define OP_Concat 91 /* same as TK_CONCAT */ -#define OP_Add 86 /* same as TK_PLUS */ -#define OP_Subtract 87 /* same as TK_MINUS */ -#define OP_Multiply 88 /* same as TK_STAR */ -#define OP_Divide 89 /* same as TK_SLASH */ -#define OP_Remainder 90 /* same as TK_REM */ -#define OP_CollSeq 17 -#define OP_Function 18 -#define OP_BitAnd 82 /* same as TK_BITAND */ -#define OP_BitOr 83 /* same as TK_BITOR */ -#define OP_ShiftLeft 84 /* same as TK_LSHIFT */ -#define OP_ShiftRight 85 /* same as TK_RSHIFT */ -#define OP_AddImm 20 -#define OP_MustBeInt 21 -#define OP_RealAffinity 22 -#define OP_ToText 141 /* same as TK_TO_TEXT */ -#define OP_ToBlob 142 /* same as TK_TO_BLOB */ -#define OP_ToNumeric 143 /* same as TK_TO_NUMERIC*/ -#define OP_ToInt 144 /* same as TK_TO_INT */ -#define OP_ToReal 145 /* same as TK_TO_REAL */ -#define OP_Eq 76 /* same as TK_EQ */ -#define OP_Ne 75 /* same as TK_NE */ -#define OP_Lt 79 /* same as TK_LT */ -#define OP_Le 78 /* same as TK_LE */ -#define OP_Gt 77 /* same as TK_GT */ -#define OP_Ge 80 /* same as TK_GE */ -#define OP_Permutation 23 -#define OP_Compare 24 -#define OP_Jump 25 -#define OP_And 69 /* same as TK_AND */ -#define OP_Or 68 /* same as TK_OR */ -#define OP_Not 19 /* same as TK_NOT */ -#define OP_BitNot 93 /* same as TK_BITNOT */ -#define OP_If 26 -#define OP_IfNot 27 -#define OP_IsNull 73 /* same as TK_ISNULL */ -#define OP_NotNull 74 /* same as TK_NOTNULL */ -#define OP_Column 28 -#define OP_Affinity 29 -#define OP_MakeRecord 30 -#define OP_Count 31 -#define OP_Savepoint 32 -#define OP_AutoCommit 33 -#define OP_Transaction 34 -#define OP_ReadCookie 35 -#define OP_SetCookie 36 -#define OP_VerifyCookie 37 -#define OP_OpenRead 38 -#define OP_OpenWrite 39 -#define OP_OpenEphemeral 40 -#define OP_OpenPseudo 41 -#define OP_Close 42 -#define OP_SeekLt 43 -#define OP_SeekLe 44 -#define OP_SeekGe 45 -#define OP_SeekGt 46 -#define OP_Seek 47 -#define OP_NotFound 48 -#define OP_Found 49 -#define OP_IsUnique 50 -#define OP_NotExists 51 -#define OP_Sequence 52 -#define OP_NewRowid 53 -#define OP_Insert 54 -#define OP_InsertInt 55 -#define OP_Delete 56 -#define OP_ResetCount 57 -#define OP_RowKey 58 -#define OP_RowData 59 -#define OP_Rowid 60 -#define OP_NullRow 61 -#define OP_Last 62 -#define OP_Sort 63 -#define OP_Rewind 64 -#define OP_Prev 65 -#define OP_Next 66 -#define OP_IdxInsert 67 -#define OP_IdxDelete 70 -#define OP_IdxRowid 71 -#define OP_IdxLT 72 -#define OP_IdxGE 81 -#define OP_Destroy 92 -#define OP_Clear 95 -#define OP_CreateIndex 96 -#define OP_CreateTable 97 -#define OP_ParseSchema 98 -#define OP_LoadAnalysis 99 -#define OP_DropTable 100 -#define OP_DropIndex 101 -#define OP_DropTrigger 102 -#define OP_IntegrityCk 103 -#define OP_RowSetAdd 104 -#define OP_RowSetRead 105 -#define OP_RowSetTest 106 -#define OP_Program 107 -#define OP_Param 108 -#define OP_FkCounter 109 -#define OP_FkIfZero 110 -#define OP_MemMax 111 -#define OP_IfPos 112 -#define OP_IfNeg 113 -#define OP_IfZero 114 -#define OP_AggStep 115 -#define OP_AggFinal 116 -#define OP_Vacuum 117 -#define OP_IncrVacuum 118 -#define OP_Expire 119 -#define OP_TableLock 120 -#define OP_VBegin 121 -#define OP_VCreate 122 -#define OP_VDestroy 123 -#define OP_VOpen 124 -#define OP_VFilter 125 -#define OP_VColumn 126 -#define OP_VNext 127 -#define OP_VRename 128 -#define OP_VUpdate 129 -#define OP_Pagecount 131 -#define OP_Trace 132 -#define OP_Noop 133 -#define OP_Explain 134 - -/* The following opcode values are never used */ -#define OP_NotUsed_135 135 -#define OP_NotUsed_136 136 -#define OP_NotUsed_137 137 -#define OP_NotUsed_138 138 -#define OP_NotUsed_139 139 -#define OP_NotUsed_140 140 - - -/* Properties such as "out2" or "jump" that are specified in -** comments following the "case" for each opcode in the vdbe.c -** are encoded into bitvectors as follows: -*/ -#define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */ -#define OPFLG_OUT2_PRERELEASE 0x0002 /* out2-prerelease: */ -#define OPFLG_IN1 0x0004 /* in1: P1 is an input */ -#define OPFLG_IN2 0x0008 /* in2: P2 is an input */ -#define OPFLG_IN3 0x0010 /* in3: P3 is an input */ -#define OPFLG_OUT2 0x0020 /* out2: P2 is an output */ -#define OPFLG_OUT3 0x0040 /* out3: P3 is an output */ -#define OPFLG_INITIALIZER {\ -/* 0 */ 0x00, 0x01, 0x05, 0x04, 0x04, 0x10, 0x00, 0x02,\ -/* 8 */ 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x24, 0x24,\ -/* 16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\ -/* 24 */ 0x00, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02,\ -/* 32 */ 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00,\ -/* 40 */ 0x00, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x08,\ -/* 48 */ 0x11, 0x11, 0x11, 0x11, 0x02, 0x02, 0x00, 0x00,\ -/* 56 */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x01,\ -/* 64 */ 0x01, 0x01, 0x01, 0x08, 0x4c, 0x4c, 0x00, 0x02,\ -/* 72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\ -/* 80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\ -/* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x02, 0x24, 0x02, 0x00,\ -/* 96 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ -/* 104 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\ -/* 112 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00,\ -/* 120 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,\ -/* 128 */ 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,\ -/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04,\ -/* 144 */ 0x04, 0x04,} - -/************** End of opcodes.h *********************************************/ -/************** Continuing where we left off in vdbe.h ***********************/ - -/* -** Prototypes for the VDBE interface. See comments on the implementation -** for a description of what each of these routines does. -*/ -SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*); -SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp); -SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1); -SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2); -SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3); -SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5); -SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); -SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N); -SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); -SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); -SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); -SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); -SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); -#ifdef SQLITE_DEBUG -SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); -SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*); -#endif -SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); -SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); -SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); -SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); -SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int); -SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); -SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); -SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *, SubProgram *, int); -SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8); -SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); -#ifndef SQLITE_OMIT_TRACE -SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); -#endif - -SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int); -SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*); -SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); - - -#ifndef NDEBUG -SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); -# define VdbeComment(X) sqlite3VdbeComment X -SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); -# define VdbeNoopComment(X) sqlite3VdbeNoopComment X -#else -# define VdbeComment(X) -# define VdbeNoopComment(X) -#endif - -#endif - -/************** End of vdbe.h ************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include pager.h in the middle of sqliteInt.h *****************/ -/************** Begin file pager.h *******************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the sqlite page cache -** subsystem. The page cache subsystem reads and writes a file a page -** at a time and provides a journal for rollback. -*/ - -#ifndef _PAGER_H_ -#define _PAGER_H_ - -/* -** Default maximum size for persistent journal files. A negative -** value means no limit. This value may be overridden using the -** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". -*/ -#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT - #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 -#endif - -/* -** The type used to represent a page number. The first page in a file -** is called page 1. 0 is used to represent "not a page". -*/ -typedef u32 Pgno; - -/* -** Each open file is managed by a separate instance of the "Pager" structure. -*/ -typedef struct Pager Pager; - -/* -** Handle type for pages. -*/ -typedef struct PgHdr DbPage; - -/* -** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is -** reserved for working around a windows/posix incompatibility). It is -** used in the journal to signify that the remainder of the journal file -** is devoted to storing a master journal name - there are no more pages to -** roll back. See comments for function writeMasterJournal() in pager.c -** for details. -*/ -#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) - -/* -** Allowed values for the flags parameter to sqlite3PagerOpen(). -** -** NOTE: These values must match the corresponding BTREE_ values in btree.h. -*/ -#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ -#define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */ - -/* -** Valid values for the second argument to sqlite3PagerLockingMode(). -*/ -#define PAGER_LOCKINGMODE_QUERY -1 -#define PAGER_LOCKINGMODE_NORMAL 0 -#define PAGER_LOCKINGMODE_EXCLUSIVE 1 - -/* -** Valid values for the second argument to sqlite3PagerJournalMode(). -*/ -#define PAGER_JOURNALMODE_QUERY -1 -#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ -#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ -#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ -#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ -#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ - -/* -** The remainder of this file contains the declarations of the functions -** that make up the Pager sub-system API. See source code comments for -** a detailed description of each routine. -*/ - -/* Open and close a Pager connection. */ -SQLITE_PRIVATE int sqlite3PagerOpen( - sqlite3_vfs*, - Pager **ppPager, - const char*, - int, - int, - int, - void(*)(DbPage*) -); -SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager); -SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); - -/* Functions used to configure a Pager object. */ -SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *); -SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u16*, int); -SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int); -SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); -SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int); -SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); -SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *, int); -SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); -SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); - -/* Functions used to obtain and release page references. */ -SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); -#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) -SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); -SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); -SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); - -/* Operations on page references. */ -SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); -SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); -SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); -SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); -SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); -SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); - -/* Functions used to manage pager transactions and savepoints. */ -SQLITE_PRIVATE int sqlite3PagerPagecount(Pager*, int*); -SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); -SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int); -SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager); -SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); -SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); -SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); -SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); -SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); - -/* Functions used to query pager state and configuration. */ -SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); -SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); -SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*); -SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*); -SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); -SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); -SQLITE_PRIVATE int sqlite3PagerNosync(Pager*); -SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); -SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); - -/* Functions used to truncate the database file. */ -SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); - -/* Functions to support testing and debugging. */ -#if !defined(NDEBUG) || defined(SQLITE_TEST) -SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); -SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); -#endif -#ifdef SQLITE_TEST -SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); -SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); - void disable_simulated_io_errors(void); - void enable_simulated_io_errors(void); -#else -# define disable_simulated_io_errors() -# define enable_simulated_io_errors() -#endif - -#endif /* _PAGER_H_ */ - -/************** End of pager.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include pcache.h in the middle of sqliteInt.h ****************/ -/************** Begin file pcache.h ******************************************/ -/* -** 2008 August 05 -** -** 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 page cache -** subsystem. -*/ - -#ifndef _PCACHE_H_ - -typedef struct PgHdr PgHdr; -typedef struct PCache PCache; - -/* -** Every page in the cache is controlled by an instance of the following -** structure. -*/ -struct PgHdr { - void *pData; /* Content of this page */ - void *pExtra; /* Extra content */ - PgHdr *pDirty; /* Transient list of dirty pages */ - Pgno pgno; /* Page number for this page */ - Pager *pPager; /* The pager this page is part of */ -#ifdef SQLITE_CHECK_PAGES - u32 pageHash; /* Hash of page content */ -#endif - u16 flags; /* PGHDR flags defined below */ - - /********************************************************************** - ** Elements above are public. All that follows is private to pcache.c - ** and should not be accessed by other modules. - */ - i16 nRef; /* Number of users of this page */ - PCache *pCache; /* Cache that owns this page */ - - PgHdr *pDirtyNext; /* Next element in list of dirty pages */ - PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ -}; - -/* Bit values for PgHdr.flags */ -#define PGHDR_DIRTY 0x002 /* Page has changed */ -#define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before - ** writing this page to the database */ -#define PGHDR_NEED_READ 0x008 /* Content is unread */ -#define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */ -#define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */ - -/* Initialize and shutdown the page cache subsystem */ -SQLITE_PRIVATE int sqlite3PcacheInitialize(void); -SQLITE_PRIVATE void sqlite3PcacheShutdown(void); - -/* Page cache buffer management: -** These routines implement SQLITE_CONFIG_PAGECACHE. -*/ -SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); - -/* Create a new pager cache. -** Under memory stress, invoke xStress to try to make pages clean. -** Only clean and unpinned pages can be reclaimed. -*/ -SQLITE_PRIVATE void sqlite3PcacheOpen( - int szPage, /* Size of every page */ - int szExtra, /* Extra space associated with each page */ - int bPurgeable, /* True if pages are on backing store */ - int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ - void *pStress, /* Argument to xStress */ - PCache *pToInit /* Preallocated space for the PCache */ -); - -/* Modify the page-size after the cache has been created. */ -SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int); - -/* Return the size in bytes of a PCache object. Used to preallocate -** storage space. -*/ -SQLITE_PRIVATE int sqlite3PcacheSize(void); - -/* One release per successful fetch. Page is pinned until released. -** Reference counted. -*/ -SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**); -SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); - -SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ -SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ -SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ -SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ - -/* Change a page number. Used by incr-vacuum. */ -SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); - -/* Remove all pages with pgno>x. Reset the cache if x==0 */ -SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); - -/* Get a list of all dirty pages in the cache, sorted by page number */ -SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); - -/* Reset and close the cache object */ -SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); - -/* Clear flags from pages of the page cache */ -SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); - -/* Discard the contents of the cache */ -SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); - -/* Return the total number of outstanding page references */ -SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*); - -/* Increment the reference count of an existing page */ -SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); - -SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*); - -/* Return the total number of pages stored in the cache */ -SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); - -#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) -/* Iterate through all dirty pages currently stored in the cache. This -** interface is only available if SQLITE_CHECK_PAGES is defined when the -** library is built. -*/ -SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); -#endif - -/* Set and get the suggested cache-size for the specified pager-cache. -** -** If no global maximum is configured, then the system attempts to limit -** the total number of pages cached by purgeable pager-caches to the sum -** of the suggested cache-sizes. -*/ -SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); -#ifdef SQLITE_TEST -SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); -#endif - -#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT -/* Try to return memory used by the pcache module to the main memory heap */ -SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); -#endif - -#ifdef SQLITE_TEST -SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); -#endif - -SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); - -#endif /* _PCACHE_H_ */ - -/************** End of pcache.h **********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - -/************** Include os.h in the middle of sqliteInt.h ********************/ -/************** Begin file os.h **********************************************/ -/* -** 2001 September 16 -** -** 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 (together with is companion C source-code file -** "os.c") attempt to abstract the underlying operating system so that -** the SQLite library will work on both POSIX and windows systems. -** -** This header file is #include-ed by sqliteInt.h and thus ends up -** being included by every source file. -*/ -#ifndef _SQLITE_OS_H_ -#define _SQLITE_OS_H_ - -/* -** Figure out if we are dealing with Unix, Windows, or some other -** operating system. After the following block of preprocess macros, -** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER -** will defined to either 1 or 0. One of the four will be 1. The other -** three will be 0. -*/ -#if defined(SQLITE_OS_OTHER) -# if SQLITE_OS_OTHER==1 -# undef SQLITE_OS_UNIX -# define SQLITE_OS_UNIX 0 -# undef SQLITE_OS_WIN -# define SQLITE_OS_WIN 0 -# undef SQLITE_OS_OS2 -# define SQLITE_OS_OS2 0 -# else -# undef SQLITE_OS_OTHER -# endif -#endif -#if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) -# define SQLITE_OS_OTHER 0 -# ifndef SQLITE_OS_WIN -# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) -# define SQLITE_OS_WIN 1 -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 0 -# elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__) -# define SQLITE_OS_WIN 0 -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 1 -# else -# define SQLITE_OS_WIN 0 -# define SQLITE_OS_UNIX 1 -# define SQLITE_OS_OS2 0 -# endif -# else -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 0 -# endif -#else -# ifndef SQLITE_OS_WIN -# define SQLITE_OS_WIN 0 -# endif -#endif - -/* -** Determine if we are dealing with WindowsCE - which has a much -** reduced API. -*/ -#if defined(_WIN32_WCE) -# define SQLITE_OS_WINCE 1 -#else -# define SQLITE_OS_WINCE 0 -#endif - - -/* -** Define the maximum size of a temporary filename -*/ -#if SQLITE_OS_WIN -# include -# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) -#elif SQLITE_OS_OS2 -# if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY) -# include /* has to be included before os2.h for linking to work */ -# endif -# define INCL_DOSDATETIME -# define INCL_DOSFILEMGR -# define INCL_DOSERRORS -# define INCL_DOSMISC -# define INCL_DOSPROCESS -# define INCL_DOSMODULEMGR -# define INCL_DOSSEMAPHORES -# include -# include -# define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP) -#else -# define SQLITE_TEMPNAME_SIZE 200 -#endif - -/* If the SET_FULLSYNC macro is not defined above, then make it -** a no-op -*/ -#ifndef SET_FULLSYNC -# define SET_FULLSYNC(x,y) -#endif - -/* -** The default size of a disk sector -*/ -#ifndef SQLITE_DEFAULT_SECTOR_SIZE -# define SQLITE_DEFAULT_SECTOR_SIZE 512 -#endif - -/* -** Temporary files are named starting with this prefix followed by 16 random -** alphanumeric characters, and no file extension. They are stored in the -** OS's standard temporary file directory, and are deleted prior to exit. -** If sqlite is being embedded in another program, you may wish to change the -** prefix to reflect your program's name, so that if your program exits -** prematurely, old temporary files can be easily identified. This can be done -** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. -** -** 2006-10-31: The default prefix used to be "sqlite_". But then -** Mcafee started using SQLite in their anti-virus product and it -** started putting files with the "sqlite" name in the c:/temp folder. -** This annoyed many windows users. Those users would then do a -** Google search for "sqlite", find the telephone numbers of the -** developers and call to wake them up at night and complain. -** For this reason, the default name prefix is changed to be "sqlite" -** spelled backwards. So the temp files are still identified, but -** anybody smart enough to figure out the code is also likely smart -** enough to know that calling the developer will not help get rid -** of the file. -*/ -#ifndef SQLITE_TEMP_FILE_PREFIX -# define SQLITE_TEMP_FILE_PREFIX "etilqs_" -#endif - -/* -** The following values may be passed as the second argument to -** sqlite3OsLock(). The various locks exhibit the following semantics: -** -** SHARED: Any number of processes may hold a SHARED lock simultaneously. -** RESERVED: A single process may hold a RESERVED lock on a file at -** any time. Other processes may hold and obtain new SHARED locks. -** PENDING: A single process may hold a PENDING lock on a file at -** any one time. Existing SHARED locks may persist, but no new -** SHARED locks may be obtained by other processes. -** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. -** -** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a -** process that requests an EXCLUSIVE lock may actually obtain a PENDING -** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to -** sqlite3OsLock(). -*/ -#define NO_LOCK 0 -#define SHARED_LOCK 1 -#define RESERVED_LOCK 2 -#define PENDING_LOCK 3 -#define EXCLUSIVE_LOCK 4 - -/* -** File Locking Notes: (Mostly about windows but also some info for Unix) -** -** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because -** those functions are not available. So we use only LockFile() and -** UnlockFile(). -** -** LockFile() prevents not just writing but also reading by other processes. -** A SHARED_LOCK is obtained by locking a single randomly-chosen -** byte out of a specific range of bytes. The lock byte is obtained at -** random so two separate readers can probably access the file at the -** same time, unless they are unlucky and choose the same lock byte. -** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. -** There can only be one writer. A RESERVED_LOCK is obtained by locking -** a single byte of the file that is designated as the reserved lock byte. -** A PENDING_LOCK is obtained by locking a designated byte different from -** the RESERVED_LOCK byte. -** -** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, -** which means we can use reader/writer locks. When reader/writer locks -** are used, the lock is placed on the same range of bytes that is used -** for probabilistic locking in Win95/98/ME. Hence, the locking scheme -** will support two or more Win95 readers or two or more WinNT readers. -** But a single Win95 reader will lock out all WinNT readers and a single -** WinNT reader will lock out all other Win95 readers. -** -** The following #defines specify the range of bytes used for locking. -** SHARED_SIZE is the number of bytes available in the pool from which -** a random byte is selected for a shared lock. The pool of bytes for -** shared locks begins at SHARED_FIRST. -** -** The same locking strategy and -** byte ranges are used for Unix. This leaves open the possiblity of having -** clients on win95, winNT, and unix all talking to the same shared file -** and all locking correctly. To do so would require that samba (or whatever -** tool is being used for file sharing) implements locks correctly between -** windows and unix. I'm guessing that isn't likely to happen, but by -** using the same locking range we are at least open to the possibility. -** -** Locking in windows is manditory. For this reason, we cannot store -** actual data in the bytes used for locking. The pager never allocates -** the pages involved in locking therefore. SHARED_SIZE is selected so -** that all locks will fit on a single page even at the minimum page size. -** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE -** is set high so that we don't have to allocate an unused page except -** for very large databases. But one should test the page skipping logic -** by setting PENDING_BYTE low and running the entire regression suite. -** -** Changing the value of PENDING_BYTE results in a subtly incompatible -** file format. Depending on how it is changed, you might not notice -** the incompatibility right away, even running a full regression test. -** The default location of PENDING_BYTE is the first byte past the -** 1GB boundary. -** -*/ -#define PENDING_BYTE sqlite3PendingByte -#define RESERVED_BYTE (PENDING_BYTE+1) -#define SHARED_FIRST (PENDING_BYTE+2) -#define SHARED_SIZE 510 - -/* -** Wrapper around OS specific sqlite3_os_init() function. -*/ -SQLITE_PRIVATE int sqlite3OsInit(void); - -/* -** Functions for accessing sqlite3_file methods -*/ -SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*); -SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); -SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); -SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); -SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); -SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); -SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); -#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 -SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); -SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); - -/* -** Functions for accessing sqlite3_vfs methods -*/ -SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); -SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); -SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); -SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); -#ifndef SQLITE_OMIT_LOAD_EXTENSION -SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); -SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); -SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); -SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); -#endif /* SQLITE_OMIT_LOAD_EXTENSION */ -SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); -SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); -SQLITE_PRIVATE int sqlite3OsCurrentTime(sqlite3_vfs *, double*); - -/* -** Convenience functions for opening and closing files using -** sqlite3_malloc() to obtain space for the file-handle structure. -*/ -SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); -SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *); - -#endif /* _SQLITE_OS_H_ */ - -/************** End of os.h **************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include mutex.h in the middle of sqliteInt.h *****************/ -/************** Begin file mutex.h *******************************************/ -/* -** 2007 August 28 -** -** 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 file contains the common header for all mutex implementations. -** The sqliteInt.h header #includes this file so that it is available -** to all source files. We break it out in an effort to keep the code -** better organized. -** -** NOTE: source files should *not* #include this header file directly. -** Source files should #include the sqliteInt.h file and let that file -** include this one indirectly. -*/ - - -/* -** Figure out what version of the code to use. The choices are -** -** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The -** mutexes implemention cannot be overridden -** at start-time. -** -** SQLITE_MUTEX_NOOP For single-threaded applications. No -** mutual exclusion is provided. But this -** implementation can be overridden at -** start-time. -** -** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. -** -** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. -** -** SQLITE_MUTEX_OS2 For multi-threaded applications on OS/2. -*/ -#if !SQLITE_THREADSAFE -# define SQLITE_MUTEX_OMIT -#endif -#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) -# if SQLITE_OS_UNIX -# define SQLITE_MUTEX_PTHREADS -# elif SQLITE_OS_WIN -# define SQLITE_MUTEX_W32 -# elif SQLITE_OS_OS2 -# define SQLITE_MUTEX_OS2 -# else -# define SQLITE_MUTEX_NOOP -# endif -#endif - -#ifdef SQLITE_MUTEX_OMIT -/* -** If this is a no-op implementation, implement everything as macros. -*/ -#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) -#define sqlite3_mutex_free(X) -#define sqlite3_mutex_enter(X) -#define sqlite3_mutex_try(X) SQLITE_OK -#define sqlite3_mutex_leave(X) -#define sqlite3_mutex_held(X) 1 -#define sqlite3_mutex_notheld(X) 1 -#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) -#define sqlite3MutexInit() SQLITE_OK -#define sqlite3MutexEnd() -#endif /* defined(SQLITE_MUTEX_OMIT) */ - -/************** End of mutex.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - - -/* -** Each database file to be accessed by the system is an instance -** of the following structure. There are normally two of these structures -** in the sqlite.aDb[] array. aDb[0] is the main database file and -** aDb[1] is the database file used to hold temporary tables. Additional -** databases may be attached. -*/ -struct Db { - char *zName; /* Name of this database */ - Btree *pBt; /* The B*Tree structure for this database file */ - u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ - u8 safety_level; /* How aggressive at syncing data to disk */ - Schema *pSchema; /* Pointer to database schema (possibly shared) */ -}; - -/* -** An instance of the following structure stores a database schema. -** -** If there are no virtual tables configured in this schema, the -** Schema.db variable is set to NULL. After the first virtual table -** has been added, it is set to point to the database connection -** used to create the connection. Once a virtual table has been -** added to the Schema structure and the Schema.db variable populated, -** only that database connection may use the Schema to prepare -** statements. -*/ -struct Schema { - int schema_cookie; /* Database schema version number for this file */ - Hash tblHash; /* All tables indexed by name */ - Hash idxHash; /* All (named) indices indexed by name */ - Hash trigHash; /* All triggers indexed by name */ - Hash fkeyHash; /* All foreign keys by referenced table name */ - Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ - u8 file_format; /* Schema format version for this file */ - u8 enc; /* Text encoding used by this database */ - u16 flags; /* Flags associated with this schema */ - int cache_size; /* Number of pages to use in the cache */ -#ifndef SQLITE_OMIT_VIRTUALTABLE - sqlite3 *db; /* "Owner" connection. See comment above */ -#endif -}; - -/* -** These macros can be used to test, set, or clear bits in the -** Db.pSchema->flags field. -*/ -#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) -#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) -#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) -#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P) - -/* -** Allowed values for the DB.pSchema->flags field. -** -** The DB_SchemaLoaded flag is set after the database schema has been -** read into internal hash tables. -** -** DB_UnresetViews means that one or more views have column names that -** have been filled out. If the schema changes, these column names might -** changes and so the view will need to be reset. -*/ -#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ -#define DB_UnresetViews 0x0002 /* Some views have defined column names */ -#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ - -/* -** The number of different kinds of things that can be limited -** using the sqlite3_limit() interface. -*/ -#define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1) - -/* -** Lookaside malloc is a set of fixed-size buffers that can be used -** to satisfy small transient memory allocation requests for objects -** associated with a particular database connection. The use of -** lookaside malloc provides a significant performance enhancement -** (approx 10%) by avoiding numerous malloc/free requests while parsing -** SQL statements. -** -** The Lookaside structure holds configuration information about the -** lookaside malloc subsystem. Each available memory allocation in -** the lookaside subsystem is stored on a linked list of LookasideSlot -** objects. -** -** Lookaside allocations are only allowed for objects that are associated -** with a particular database connection. Hence, schema information cannot -** be stored in lookaside because in shared cache mode the schema information -** is shared by multiple database connections. Therefore, while parsing -** schema information, the Lookaside.bEnabled flag is cleared so that -** lookaside allocations are not used to construct the schema objects. -*/ -struct Lookaside { - u16 sz; /* Size of each buffer in bytes */ - u8 bEnabled; /* False to disable new lookaside allocations */ - u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ - int nOut; /* Number of buffers currently checked out */ - int mxOut; /* Highwater mark for nOut */ - LookasideSlot *pFree; /* List of available buffers */ - void *pStart; /* First byte of available memory space */ - void *pEnd; /* First byte past end of available space */ -}; -struct LookasideSlot { - LookasideSlot *pNext; /* Next buffer in the list of free buffers */ -}; - -/* -** A hash table for function definitions. -** -** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. -** Collisions are on the FuncDef.pHash chain. -*/ -struct FuncDefHash { - FuncDef *a[23]; /* Hash table for functions */ -}; - -/* -** Each database connection is an instance of the following structure. -** -** The sqlite.lastRowid records the last insert rowid generated by an -** insert statement. Inserts on views do not affect its value. Each -** trigger has its own context, so that lastRowid can be updated inside -** triggers as usual. The previous value will be restored once the trigger -** exits. Upon entering a before or instead of trigger, lastRowid is no -** longer (since after version 2.8.12) reset to -1. -** -** The sqlite.nChange does not count changes within triggers and keeps no -** context. It is reset at start of sqlite3_exec. -** The sqlite.lsChange represents the number of changes made by the last -** insert, update, or delete statement. It remains constant throughout the -** length of a statement and is then updated by OP_SetCounts. It keeps a -** context stack just like lastRowid so that the count of changes -** within a trigger is not seen outside the trigger. Changes to views do not -** affect the value of lsChange. -** The sqlite.csChange keeps track of the number of current changes (since -** the last statement) and is used to update sqlite_lsChange. -** -** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16 -** store the most recent error code and, if applicable, string. The -** internal function sqlite3Error() is used to set these variables -** consistently. -*/ -struct sqlite3 { - sqlite3_vfs *pVfs; /* OS Interface */ - int nDb; /* Number of backends currently in use */ - Db *aDb; /* All backends */ - int flags; /* Miscellaneous flags. See below */ - int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ - int errCode; /* Most recent error code (SQLITE_*) */ - int errMask; /* & result codes with this before returning */ - u8 autoCommit; /* The auto-commit flag. */ - u8 temp_store; /* 1: file 2: memory 0: default */ - u8 mallocFailed; /* True if we have seen a malloc failure */ - u8 dfltLockMode; /* Default locking-mode for attached dbs */ - u8 dfltJournalMode; /* Default journal mode for attached dbs */ - signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ - u8 suppressErr; /* Do not issue error messages if true */ - int nextPagesize; /* Pagesize after VACUUM if >0 */ - int nTable; /* Number of tables in the database */ - CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ - i64 lastRowid; /* ROWID of most recent insert (see above) */ - u32 magic; /* Magic number for detect library misuse */ - int nChange; /* Value returned by sqlite3_changes() */ - int nTotalChange; /* Value returned by sqlite3_total_changes() */ - sqlite3_mutex *mutex; /* Connection mutex */ - int aLimit[SQLITE_N_LIMIT]; /* Limits */ - struct sqlite3InitInfo { /* Information used during initialization */ - int iDb; /* When back is being initialized */ - int newTnum; /* Rootpage of table being initialized */ - u8 busy; /* TRUE if currently initializing */ - u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */ - } init; - int nExtension; /* Number of loaded extensions */ - void **aExtension; /* Array of shared library handles */ - struct Vdbe *pVdbe; /* List of active virtual machines */ - int activeVdbeCnt; /* Number of VDBEs currently executing */ - int writeVdbeCnt; /* Number of active VDBEs that are writing */ - void (*xTrace)(void*,const char*); /* Trace function */ - void *pTraceArg; /* Argument to the trace function */ - void (*xProfile)(void*,const char*,u64); /* Profiling function */ - void *pProfileArg; /* Argument to profile function */ - void *pCommitArg; /* Argument to xCommitCallback() */ - int (*xCommitCallback)(void*); /* Invoked at every commit. */ - void *pRollbackArg; /* Argument to xRollbackCallback() */ - void (*xRollbackCallback)(void*); /* Invoked at every commit. */ - void *pUpdateArg; - void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); - void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); - void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); - void *pCollNeededArg; - sqlite3_value *pErr; /* Most recent error message */ - char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ - char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ - union { - volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ - double notUsed1; /* Spacer */ - } u1; - Lookaside lookaside; /* Lookaside malloc configuration */ -#ifndef SQLITE_OMIT_AUTHORIZATION - int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); - /* Access authorization function */ - void *pAuthArg; /* 1st argument to the access auth function */ -#endif -#ifndef SQLITE_OMIT_PROGRESS_CALLBACK - int (*xProgress)(void *); /* The progress callback */ - void *pProgressArg; /* Argument to the progress callback */ - int nProgressOps; /* Number of opcodes for progress callback */ -#endif -#ifndef SQLITE_OMIT_VIRTUALTABLE - Hash aModule; /* populated by sqlite3_create_module() */ - Table *pVTab; /* vtab with active Connect/Create method */ - VTable **aVTrans; /* Virtual tables with open transactions */ - int nVTrans; /* Allocated size of aVTrans */ - VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ -#endif - FuncDefHash aFunc; /* Hash table of connection functions */ - Hash aCollSeq; /* All collating sequences */ - BusyHandler busyHandler; /* Busy callback */ - int busyTimeout; /* Busy handler timeout, in msec */ - Db aDbStatic[2]; /* Static space for the 2 default backends */ - Savepoint *pSavepoint; /* List of active savepoints */ - int nSavepoint; /* Number of non-transaction savepoints */ - int nStatement; /* Number of nested statement-transactions */ - u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ - i64 nDeferredCons; /* Net deferred constraints this transaction. */ - -#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY - /* The following variables are all protected by the STATIC_MASTER - ** mutex, not by sqlite3.mutex. They are used by code in notify.c. - ** - ** When X.pUnlockConnection==Y, that means that X is waiting for Y to - ** unlock so that it can proceed. - ** - ** When X.pBlockingConnection==Y, that means that something that X tried - ** tried to do recently failed with an SQLITE_LOCKED error due to locks - ** held by Y. - */ - sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ - sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ - void *pUnlockArg; /* Argument to xUnlockNotify */ - void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ - sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ -#endif -}; - -/* -** A macro to discover the encoding of a database. -*/ -#define ENC(db) ((db)->aDb[0].pSchema->enc) - -/* -** Possible values for the sqlite3.flags. -*/ -#define SQLITE_VdbeTrace 0x00000100 /* True to trace VDBE execution */ -#define SQLITE_InternChanges 0x00000200 /* Uncommitted Hash table changes */ -#define SQLITE_FullColNames 0x00000400 /* Show full column names on SELECT */ -#define SQLITE_ShortColNames 0x00000800 /* Show short columns names */ -#define SQLITE_CountRows 0x00001000 /* Count rows changed by INSERT, */ - /* DELETE, or UPDATE and return */ - /* the count using a callback. */ -#define SQLITE_NullCallback 0x00002000 /* Invoke the callback once if the */ - /* result set is empty */ -#define SQLITE_SqlTrace 0x00004000 /* Debug print SQL as it executes */ -#define SQLITE_VdbeListing 0x00008000 /* Debug listings of VDBE programs */ -#define SQLITE_WriteSchema 0x00010000 /* OK to update SQLITE_MASTER */ -#define SQLITE_NoReadlock 0x00020000 /* Readlocks are omitted when - ** accessing read-only databases */ -#define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */ -#define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */ -#define SQLITE_LegacyFileFmt 0x00100000 /* Create new databases in format 1 */ -#define SQLITE_FullFSync 0x00200000 /* Use full fsync on the backend */ -#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */ -#define SQLITE_RecoveryMode 0x00800000 /* Ignore schema errors */ -#define SQLITE_ReverseOrder 0x01000000 /* Reverse unordered SELECTs */ -#define SQLITE_RecTriggers 0x02000000 /* Enable recursive triggers */ -#define SQLITE_ForeignKeys 0x04000000 /* Enforce foreign key constraints */ - -/* -** Bits of the sqlite3.flags field that are used by the -** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface. -** These must be the low-order bits of the flags field. -*/ -#define SQLITE_QueryFlattener 0x01 /* Disable query flattening */ -#define SQLITE_ColumnCache 0x02 /* Disable the column cache */ -#define SQLITE_IndexSort 0x04 /* Disable indexes for sorting */ -#define SQLITE_IndexSearch 0x08 /* Disable indexes for searching */ -#define SQLITE_IndexCover 0x10 /* Disable index covering table */ -#define SQLITE_OptMask 0x1f /* Mask of all disablable opts */ - -/* -** Possible values for the sqlite.magic field. -** The numbers are obtained at random and have no special meaning, other -** than being distinct from one another. -*/ -#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ -#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ -#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ -#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ -#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ - -/* -** Each SQL function is defined by an instance of the following -** structure. A pointer to this structure is stored in the sqlite.aFunc -** hash table. When multiple functions have the same name, the hash table -** points to a linked list of these structures. -*/ -struct FuncDef { - i16 nArg; /* Number of arguments. -1 means unlimited */ - u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ - u8 flags; /* Some combination of SQLITE_FUNC_* */ - void *pUserData; /* User data parameter */ - FuncDef *pNext; /* Next function with same name */ - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ - void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ - void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */ - char *zName; /* SQL name of the function. */ - FuncDef *pHash; /* Next with a different name but the same hash */ -}; - -/* -** Possible values for FuncDef.flags -*/ -#define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ -#define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ -#define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */ -#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */ -#define SQLITE_FUNC_PRIVATE 0x10 /* Allowed for internal use only */ -#define SQLITE_FUNC_COUNT 0x20 /* Built-in count(*) aggregate */ -#define SQLITE_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */ - -/* -** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are -** used to create the initializers for the FuncDef structures. -** -** FUNCTION(zName, nArg, iArg, bNC, xFunc) -** Used to create a scalar function definition of a function zName -** implemented by C function xFunc that accepts nArg arguments. The -** value passed as iArg is cast to a (void*) and made available -** as the user-data (sqlite3_user_data()) for the function. If -** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. -** -** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) -** Used to create an aggregate function definition implemented by -** the C functions xStep and xFinal. The first four parameters -** are interpreted in the same way as the first 4 parameters to -** FUNCTION(). -** -** LIKEFUNC(zName, nArg, pArg, flags) -** Used to create a scalar function definition of a function zName -** that accepts nArg arguments and is implemented by a call to C -** function likeFunc. Argument pArg is cast to a (void *) and made -** available as the function user-data (sqlite3_user_data()). The -** FuncDef.flags variable is set to the value passed as the flags -** parameter. -*/ -#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0} -#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ - pArg, 0, xFunc, 0, 0, #zName, 0} -#define LIKEFUNC(zName, nArg, arg, flags) \ - {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0} -#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ - {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \ - SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0} - -/* -** All current savepoints are stored in a linked list starting at -** sqlite3.pSavepoint. The first element in the list is the most recently -** opened savepoint. Savepoints are added to the list by the vdbe -** OP_Savepoint instruction. -*/ -struct Savepoint { - char *zName; /* Savepoint name (nul-terminated) */ - i64 nDeferredCons; /* Number of deferred fk violations */ - Savepoint *pNext; /* Parent savepoint (if any) */ -}; - -/* -** The following are used as the second parameter to sqlite3Savepoint(), -** and as the P1 argument to the OP_Savepoint instruction. -*/ -#define SAVEPOINT_BEGIN 0 -#define SAVEPOINT_RELEASE 1 -#define SAVEPOINT_ROLLBACK 2 - - -/* -** Each SQLite module (virtual table definition) is defined by an -** instance of the following structure, stored in the sqlite3.aModule -** hash table. -*/ -struct Module { - const sqlite3_module *pModule; /* Callback pointers */ - const char *zName; /* Name passed to create_module() */ - void *pAux; /* pAux passed to create_module() */ - void (*xDestroy)(void *); /* Module destructor function */ -}; - -/* -** information about each column of an SQL table is held in an instance -** of this structure. -*/ -struct Column { - char *zName; /* Name of this column */ - Expr *pDflt; /* Default value of this column */ - char *zDflt; /* Original text of the default value */ - char *zType; /* Data type for this column */ - char *zColl; /* Collating sequence. If NULL, use the default */ - u8 notNull; /* True if there is a NOT NULL constraint */ - u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ - char affinity; /* One of the SQLITE_AFF_... values */ -#ifndef SQLITE_OMIT_VIRTUALTABLE - u8 isHidden; /* True if this column is 'hidden' */ -#endif -}; - -/* -** A "Collating Sequence" is defined by an instance of the following -** structure. Conceptually, a collating sequence consists of a name and -** a comparison routine that defines the order of that sequence. -** -** There may two separate implementations of the collation function, one -** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that -** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine -** native byte order. When a collation sequence is invoked, SQLite selects -** the version that will require the least expensive encoding -** translations, if any. -** -** The CollSeq.pUser member variable is an extra parameter that passed in -** as the first argument to the UTF-8 comparison function, xCmp. -** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function, -** xCmp16. -** -** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the -** collating sequence is undefined. Indices built on an undefined -** collating sequence may not be read or written. -*/ -struct CollSeq { - char *zName; /* Name of the collating sequence, UTF-8 encoded */ - u8 enc; /* Text encoding handled by xCmp() */ - u8 type; /* One of the SQLITE_COLL_... values below */ - void *pUser; /* First argument to xCmp() */ - int (*xCmp)(void*,int, const void*, int, const void*); - void (*xDel)(void*); /* Destructor for pUser */ -}; - -/* -** Allowed values of CollSeq.type: -*/ -#define SQLITE_COLL_BINARY 1 /* The default memcmp() collating sequence */ -#define SQLITE_COLL_NOCASE 2 /* The built-in NOCASE collating sequence */ -#define SQLITE_COLL_REVERSE 3 /* The built-in REVERSE collating sequence */ -#define SQLITE_COLL_USER 0 /* Any other user-defined collating sequence */ - -/* -** A sort order can be either ASC or DESC. -*/ -#define SQLITE_SO_ASC 0 /* Sort in ascending order */ -#define SQLITE_SO_DESC 1 /* Sort in ascending order */ - -/* -** Column affinity types. -** -** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and -** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve -** the speed a little by numbering the values consecutively. -** -** But rather than start with 0 or 1, we begin with 'a'. That way, -** when multiple affinity types are concatenated into a string and -** used as the P4 operand, they will be more readable. -** -** Note also that the numeric types are grouped together so that testing -** for a numeric type is a single comparison. -*/ -#define SQLITE_AFF_TEXT 'a' -#define SQLITE_AFF_NONE 'b' -#define SQLITE_AFF_NUMERIC 'c' -#define SQLITE_AFF_INTEGER 'd' -#define SQLITE_AFF_REAL 'e' - -#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) - -/* -** The SQLITE_AFF_MASK values masks off the significant bits of an -** affinity value. -*/ -#define SQLITE_AFF_MASK 0x67 - -/* -** Additional bit values that can be ORed with an affinity without -** changing the affinity. -*/ -#define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */ -#define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */ -#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ - -/* -** An object of this type is created for each virtual table present in -** the database schema. -** -** If the database schema is shared, then there is one instance of this -** structure for each database connection (sqlite3*) that uses the shared -** schema. This is because each database connection requires its own unique -** instance of the sqlite3_vtab* handle used to access the virtual table -** implementation. sqlite3_vtab* handles can not be shared between -** database connections, even when the rest of the in-memory database -** schema is shared, as the implementation often stores the database -** connection handle passed to it via the xConnect() or xCreate() method -** during initialization internally. This database connection handle may -** then used by the virtual table implementation to access real tables -** within the database. So that they appear as part of the callers -** transaction, these accesses need to be made via the same database -** connection as that used to execute SQL operations on the virtual table. -** -** All VTable objects that correspond to a single table in a shared -** database schema are initially stored in a linked-list pointed to by -** the Table.pVTable member variable of the corresponding Table object. -** When an sqlite3_prepare() operation is required to access the virtual -** table, it searches the list for the VTable that corresponds to the -** database connection doing the preparing so as to use the correct -** sqlite3_vtab* handle in the compiled query. -** -** When an in-memory Table object is deleted (for example when the -** schema is being reloaded for some reason), the VTable objects are not -** deleted and the sqlite3_vtab* handles are not xDisconnect()ed -** immediately. Instead, they are moved from the Table.pVTable list to -** another linked list headed by the sqlite3.pDisconnect member of the -** corresponding sqlite3 structure. They are then deleted/xDisconnected -** next time a statement is prepared using said sqlite3*. This is done -** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. -** Refer to comments above function sqlite3VtabUnlockList() for an -** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect -** list without holding the corresponding sqlite3.mutex mutex. -** -** The memory for objects of this type is always allocated by -** sqlite3DbMalloc(), using the connection handle stored in VTable.db as -** the first argument. -*/ -struct VTable { - sqlite3 *db; /* Database connection associated with this table */ - Module *pMod; /* Pointer to module implementation */ - sqlite3_vtab *pVtab; /* Pointer to vtab instance */ - int nRef; /* Number of pointers to this structure */ - VTable *pNext; /* Next in linked list (see above) */ -}; - -/* -** Each SQL table is represented in memory by an instance of the -** following structure. -** -** Table.zName is the name of the table. The case of the original -** CREATE TABLE statement is stored, but case is not significant for -** comparisons. -** -** Table.nCol is the number of columns in this table. Table.aCol is a -** pointer to an array of Column structures, one for each column. -** -** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of -** the column that is that key. Otherwise Table.iPKey is negative. Note -** that the datatype of the PRIMARY KEY must be INTEGER for this field to -** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of -** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid -** is generated for each row of the table. TF_HasPrimaryKey is set if -** the table has any PRIMARY KEY, INTEGER or otherwise. -** -** Table.tnum is the page number for the root BTree page of the table in the -** database file. If Table.iDb is the index of the database table backend -** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that -** holds temporary tables and indices. If TF_Ephemeral is set -** then the table is stored in a file that is automatically deleted -** when the VDBE cursor to the table is closed. In this case Table.tnum -** refers VDBE cursor number that holds the table open, not to the root -** page number. Transient tables are used to hold the results of a -** sub-query that appears instead of a real table name in the FROM clause -** of a SELECT statement. -*/ -struct Table { - sqlite3 *dbMem; /* DB connection used for lookaside allocations. */ - char *zName; /* Name of the table or view */ - int iPKey; /* If not negative, use aCol[iPKey] as the primary key */ - int nCol; /* Number of columns in this table */ - Column *aCol; /* Information about each column */ - Index *pIndex; /* List of SQL indexes on this table. */ - int tnum; /* Root BTree node for this table (see note above) */ - Select *pSelect; /* NULL for tables. Points to definition if a view. */ - u16 nRef; /* Number of pointers to this Table */ - u8 tabFlags; /* Mask of TF_* values */ - u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ - FKey *pFKey; /* Linked list of all foreign keys in this table */ - char *zColAff; /* String defining the affinity of each column */ -#ifndef SQLITE_OMIT_CHECK - Expr *pCheck; /* The AND of all CHECK constraints */ -#endif -#ifndef SQLITE_OMIT_ALTERTABLE - int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ -#endif -#ifndef SQLITE_OMIT_VIRTUALTABLE - VTable *pVTable; /* List of VTable objects. */ - int nModuleArg; /* Number of arguments to the module */ - char **azModuleArg; /* Text of all module args. [0] is module name */ -#endif - Trigger *pTrigger; /* List of triggers stored in pSchema */ - Schema *pSchema; /* Schema that contains this table */ - Table *pNextZombie; /* Next on the Parse.pZombieTab list */ -}; - -/* -** Allowed values for Tabe.tabFlags. -*/ -#define TF_Readonly 0x01 /* Read-only system table */ -#define TF_Ephemeral 0x02 /* An ephemeral table */ -#define TF_HasPrimaryKey 0x04 /* Table has a primary key */ -#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */ -#define TF_Virtual 0x10 /* Is a virtual table */ -#define TF_NeedMetadata 0x20 /* aCol[].zType and aCol[].pColl missing */ - - - -/* -** Test to see whether or not a table is a virtual table. This is -** done as a macro so that it will be optimized out when virtual -** table support is omitted from the build. -*/ -#ifndef SQLITE_OMIT_VIRTUALTABLE -# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) -# define IsHiddenColumn(X) ((X)->isHidden) -#else -# define IsVirtual(X) 0 -# define IsHiddenColumn(X) 0 -#endif - -/* -** Each foreign key constraint is an instance of the following structure. -** -** A foreign key is associated with two tables. The "from" table is -** the table that contains the REFERENCES clause that creates the foreign -** key. The "to" table is the table that is named in the REFERENCES clause. -** Consider this example: -** -** CREATE TABLE ex1( -** a INTEGER PRIMARY KEY, -** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) -** ); -** -** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". -** -** Each REFERENCES clause generates an instance of the following structure -** which is attached to the from-table. The to-table need not exist when -** the from-table is created. The existence of the to-table is not checked. -*/ -struct FKey { - Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ - FKey *pNextFrom; /* Next foreign key in pFrom */ - char *zTo; /* Name of table that the key points to (aka: Parent) */ - FKey *pNextTo; /* Next foreign key on table named zTo */ - FKey *pPrevTo; /* Previous foreign key on table named zTo */ - int nCol; /* Number of columns in this key */ - /* EV: R-30323-21917 */ - u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ - u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ - Trigger *apTrigger[2]; /* Triggers for aAction[] actions */ - struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ - int iFrom; /* Index of column in pFrom */ - char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ - } aCol[1]; /* One entry for each of nCol column s */ -}; - -/* -** SQLite supports many different ways to resolve a constraint -** error. ROLLBACK processing means that a constraint violation -** causes the operation in process to fail and for the current transaction -** to be rolled back. ABORT processing means the operation in process -** fails and any prior changes from that one operation are backed out, -** but the transaction is not rolled back. FAIL processing means that -** the operation in progress stops and returns an error code. But prior -** changes due to the same operation are not backed out and no rollback -** occurs. IGNORE means that the particular row that caused the constraint -** error is not inserted or updated. Processing continues and no error -** is returned. REPLACE means that preexisting database rows that caused -** a UNIQUE constraint violation are removed so that the new insert or -** update can proceed. Processing continues and no error is reported. -** -** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. -** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the -** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign -** key is set to NULL. CASCADE means that a DELETE or UPDATE of the -** referenced table row is propagated into the row that holds the -** foreign key. -** -** The following symbolic values are used to record which type -** of action to take. -*/ -#define OE_None 0 /* There is no constraint to check */ -#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ -#define OE_Abort 2 /* Back out changes but do no rollback transaction */ -#define OE_Fail 3 /* Stop the operation but leave all prior changes */ -#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ -#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ - -#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ -#define OE_SetNull 7 /* Set the foreign key value to NULL */ -#define OE_SetDflt 8 /* Set the foreign key value to its default */ -#define OE_Cascade 9 /* Cascade the changes */ - -#define OE_Default 99 /* Do whatever the default action is */ - - -/* -** An instance of the following structure is passed as the first -** argument to sqlite3VdbeKeyCompare and is used to control the -** comparison of the two index keys. -*/ -struct KeyInfo { - sqlite3 *db; /* The database connection */ - u8 enc; /* Text encoding - one of the TEXT_Utf* values */ - u16 nField; /* Number of entries in aColl[] */ - u8 *aSortOrder; /* If defined an aSortOrder[i] is true, sort DESC */ - CollSeq *aColl[1]; /* Collating sequence for each term of the key */ -}; - -/* -** An instance of the following structure holds information about a -** single index record that has already been parsed out into individual -** values. -** -** A record is an object that contains one or more fields of data. -** Records are used to store the content of a table row and to store -** the key of an index. A blob encoding of a record is created by -** the OP_MakeRecord opcode of the VDBE and is disassembled by the -** OP_Column opcode. -** -** This structure holds a record that has already been disassembled -** into its constituent fields. -*/ -struct UnpackedRecord { - KeyInfo *pKeyInfo; /* Collation and sort-order information */ - u16 nField; /* Number of entries in apMem[] */ - u16 flags; /* Boolean settings. UNPACKED_... below */ - i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */ - Mem *aMem; /* Values */ -}; - -/* -** Allowed values of UnpackedRecord.flags -*/ -#define UNPACKED_NEED_FREE 0x0001 /* Memory is from sqlite3Malloc() */ -#define UNPACKED_NEED_DESTROY 0x0002 /* apMem[]s should all be destroyed */ -#define UNPACKED_IGNORE_ROWID 0x0004 /* Ignore trailing rowid on key1 */ -#define UNPACKED_INCRKEY 0x0008 /* Make this key an epsilon larger */ -#define UNPACKED_PREFIX_MATCH 0x0010 /* A prefix match is considered OK */ -#define UNPACKED_PREFIX_SEARCH 0x0020 /* A prefix match is considered OK */ - -/* -** Each SQL index is represented in memory by an -** instance of the following structure. -** -** The columns of the table that are to be indexed are described -** by the aiColumn[] field of this structure. For example, suppose -** we have the following table and index: -** -** CREATE TABLE Ex1(c1 int, c2 int, c3 text); -** CREATE INDEX Ex2 ON Ex1(c3,c1); -** -** In the Table structure describing Ex1, nCol==3 because there are -** three columns in the table. In the Index structure describing -** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. -** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the -** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. -** The second column to be indexed (c1) has an index of 0 in -** Ex1.aCol[], hence Ex2.aiColumn[1]==0. -** -** The Index.onError field determines whether or not the indexed columns -** must be unique and what to do if they are not. When Index.onError=OE_None, -** it means this is not a unique index. Otherwise it is a unique index -** and the value of Index.onError indicate the which conflict resolution -** algorithm to employ whenever an attempt is made to insert a non-unique -** element. -*/ -struct Index { - char *zName; /* Name of this index */ - int nColumn; /* Number of columns in the table used by this index */ - int *aiColumn; /* Which columns are used by this index. 1st is 0 */ - unsigned *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */ - Table *pTable; /* The SQL table being indexed */ - int tnum; /* Page containing root of this index in database file */ - u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ - u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ - char *zColAff; /* String defining the affinity of each column */ - Index *pNext; /* The next index associated with the same table */ - Schema *pSchema; /* Schema containing this index */ - u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */ - char **azColl; /* Array of collation sequence names for index */ - IndexSample *aSample; /* Array of SQLITE_INDEX_SAMPLES samples */ -}; - -/* -** Each sample stored in the sqlite_stat2 table is represented in memory -** using a structure of this type. -*/ -struct IndexSample { - union { - char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */ - double r; /* Value if eType is SQLITE_FLOAT or SQLITE_INTEGER */ - } u; - u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */ - u8 nByte; /* Size in byte of text or blob. */ -}; - -/* -** Each token coming out of the lexer is an instance of -** this structure. Tokens are also used as part of an expression. -** -** Note if Token.z==0 then Token.dyn and Token.n are undefined and -** may contain random values. Do not make any assumptions about Token.dyn -** and Token.n when Token.z==0. -*/ -struct Token { - const char *z; /* Text of the token. Not NULL-terminated! */ - unsigned int n; /* Number of characters in this token */ -}; - -/* -** An instance of this structure contains information needed to generate -** code for a SELECT that contains aggregate functions. -** -** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a -** pointer to this structure. The Expr.iColumn field is the index in -** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate -** code for that node. -** -** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the -** original Select structure that describes the SELECT statement. These -** fields do not need to be freed when deallocating the AggInfo structure. -*/ -struct AggInfo { - u8 directMode; /* Direct rendering mode means take data directly - ** from source tables rather than from accumulators */ - u8 useSortingIdx; /* In direct mode, reference the sorting index rather - ** than the source table */ - int sortingIdx; /* Cursor number of the sorting index */ - ExprList *pGroupBy; /* The group by clause */ - int nSortingColumn; /* Number of columns in the sorting index */ - struct AggInfo_col { /* For each column used in source tables */ - Table *pTab; /* Source table */ - int iTable; /* Cursor number of the source table */ - int iColumn; /* Column number within the source table */ - int iSorterColumn; /* Column number in the sorting index */ - int iMem; /* Memory location that acts as accumulator */ - Expr *pExpr; /* The original expression */ - } *aCol; - int nColumn; /* Number of used entries in aCol[] */ - int nColumnAlloc; /* Number of slots allocated for aCol[] */ - int nAccumulator; /* Number of columns that show through to the output. - ** Additional columns are used only as parameters to - ** aggregate functions */ - struct AggInfo_func { /* For each aggregate function */ - Expr *pExpr; /* Expression encoding the function */ - FuncDef *pFunc; /* The aggregate function implementation */ - int iMem; /* Memory location that acts as accumulator */ - int iDistinct; /* Ephemeral table used to enforce DISTINCT */ - } *aFunc; - int nFunc; /* Number of entries in aFunc[] */ - int nFuncAlloc; /* Number of slots allocated for aFunc[] */ -}; - -/* -** The datatype ynVar is a signed integer, either 16-bit or 32-bit. -** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater -** than 32767 we have to make it 32-bit. 16-bit is preferred because -** it uses less memory in the Expr object, which is a big memory user -** in systems with lots of prepared statements. And few applications -** need more than about 10 or 20 variables. But some extreme users want -** to have prepared statements with over 32767 variables, and for them -** the option is available (at compile-time). -*/ -#if SQLITE_MAX_VARIABLE_NUMBER<=32767 -typedef i16 ynVar; -#else -typedef int ynVar; -#endif - -/* -** Each node of an expression in the parse tree is an instance -** of this structure. -** -** Expr.op is the opcode. The integer parser token codes are reused -** as opcodes here. For example, the parser defines TK_GE to be an integer -** code representing the ">=" operator. This same integer code is reused -** to represent the greater-than-or-equal-to operator in the expression -** tree. -** -** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, -** or TK_STRING), then Expr.token contains the text of the SQL literal. If -** the expression is a variable (TK_VARIABLE), then Expr.token contains the -** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), -** then Expr.token contains the name of the function. -** -** Expr.pRight and Expr.pLeft are the left and right subexpressions of a -** binary operator. Either or both may be NULL. -** -** Expr.x.pList is a list of arguments if the expression is an SQL function, -** a CASE expression or an IN expression of the form " IN (, ...)". -** Expr.x.pSelect is used if the expression is a sub-select or an expression of -** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the -** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is -** valid. -** -** An expression of the form ID or ID.ID refers to a column in a table. -** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is -** the integer cursor number of a VDBE cursor pointing to that table and -** Expr.iColumn is the column number for the specific column. If the -** expression is used as a result in an aggregate SELECT, then the -** value is also stored in the Expr.iAgg column in the aggregate so that -** it can be accessed after all aggregates are computed. -** -** If the expression is an unbound variable marker (a question mark -** character '?' in the original SQL) then the Expr.iTable holds the index -** number for that variable. -** -** If the expression is a subquery then Expr.iColumn holds an integer -** register number containing the result of the subquery. If the -** subquery gives a constant result, then iTable is -1. If the subquery -** gives a different answer at different times during statement processing -** then iTable is the address of a subroutine that computes the subquery. -** -** If the Expr is of type OP_Column, and the table it is selecting from -** is a disk table or the "old.*" pseudo-table, then pTab points to the -** corresponding table definition. -** -** ALLOCATION NOTES: -** -** Expr objects can use a lot of memory space in database schema. To -** help reduce memory requirements, sometimes an Expr object will be -** truncated. And to reduce the number of memory allocations, sometimes -** two or more Expr objects will be stored in a single memory allocation, -** together with Expr.zToken strings. -** -** If the EP_Reduced and EP_TokenOnly flags are set when -** an Expr object is truncated. When EP_Reduced is set, then all -** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees -** are contained within the same memory allocation. Note, however, that -** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately -** allocated, regardless of whether or not EP_Reduced is set. -*/ -struct Expr { - u8 op; /* Operation performed by this node */ - char affinity; /* The affinity of the column or 0 if not a column */ - u16 flags; /* Various flags. EP_* See below */ - union { - char *zToken; /* Token value. Zero terminated and dequoted */ - int iValue; /* Integer value if EP_IntValue */ - } u; - - /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no - ** space is allocated for the fields below this point. An attempt to - ** access them will result in a segfault or malfunction. - *********************************************************************/ - - Expr *pLeft; /* Left subnode */ - Expr *pRight; /* Right subnode */ - union { - ExprList *pList; /* Function arguments or in " IN ( IN (