From 9a4f8534436454029078b6b134cf28ede8cf230e Mon Sep 17 00:00:00 2001 From: "Rajdeep Mehra (mehrar)" Date: Fri, 15 Oct 2021 22:58:53 +0100 Subject: [PATCH] Add files via upload --- libsqlite3 (1).a | Bin 0 -> 178670 bytes sqlite3.dll | 1024 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1024 insertions(+) create mode 100644 libsqlite3 (1).a create mode 100644 sqlite3.dll diff --git a/libsqlite3 (1).a b/libsqlite3 (1).a new file mode 100644 index 0000000000000000000000000000000000000000..c71af576472e2904df84c087d4e101f6127ffab3 GIT binary patch literal 178670 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 literal 0 HcmV?d00001 diff --git a/sqlite3.dll b/sqlite3.dll new file mode 100644 index 0000000..5c60c71 --- /dev/null +++ b/sqlite3.dll @@ -0,0 +1,1024 @@ +/* +** 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 supposed to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +*/ +#ifndef SQLITE3_H +#define SQLITE3_H +#include /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +extern "C" { +#endif + + +/* +** Provide the ability to override linkage features of the interface. +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif +#ifndef SQLITE_API +# define SQLITE_API +#endif +#ifndef SQLITE_CDECL +# define SQLITE_CDECL +#endif +#ifndef SQLITE_APICALL +# define SQLITE_APICALL +#endif +#ifndef SQLITE_STDCALL +# define SQLITE_STDCALL SQLITE_APICALL +#endif +#ifndef SQLITE_CALLBACK +# define SQLITE_CALLBACK +#endif +#ifndef SQLITE_SYSAPI +# define SQLITE_SYSAPI +#endif + +/* +** These no-op macros are used in front of interfaces to mark those +** interfaces as either deprecated or experimental. New applications +** should not use deprecated interfaces - they are supported for backwards +** compatibility only. Application writers should be aware that +** experimental interfaces are subject to change in point releases. +** +** These macros used to resolve to various kinds of compiler magic that +** would generate warning messages when they were used. But that +** compiler magic ended up generating such a flurry of bug reports +** that we have taken it all out and gone back to using simple +** noop macros. +*/ +#define SQLITE_DEPRECATED +#define SQLITE_EXPERIMENTAL + +/* +** Ensure these symbols were not defined by some previous header file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers +** +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header +** evaluates to a string literal that is the SQLite version in the +** format "X.Y.Z" where X is the major version number (always 3 for +** SQLite3) and Y is the minor version number and Z is the release number.)^ +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same +** numbers used in [SQLITE_VERSION].)^ +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also +** be larger than the release from which it is derived. Either Y will +** be held constant and Z will be incremented or else Y will be incremented +** and Z will be reset to zero. +** +** Since [version 3.6.18] ([dateof:3.6.18]), +** SQLite source code has been stored in the +** Fossil configuration management +** system. ^The SQLITE_SOURCE_ID macro evaluates to +** a string which identifies a particular check-in of SQLite +** within its configuration management system. ^The SQLITE_SOURCE_ID +** string contains the date and time of the check-in (UTC) and 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.16.2" +#define SQLITE_VERSION_NUMBER 3016002 +#define SQLITE_SOURCE_ID "2017-01-06 16:32:41 a65a62893ca8319e89e48b8a38cf8a59c69a8209" + +/* +** CAPI3REF: Run-Time Library Version Numbers +** KEYWORDS: sqlite3_version sqlite3_sourceid +** +** These interfaces provide the same information as the [SQLITE_VERSION], +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros +** but are associated with the library instead of the header file. ^(Cautious +** programmers might include assert() statements in their application to +** verify that values returned by these interfaces match the macros in +** the header, and thus ensure that the application is +** compiled with matching library and header files. +** +** 
+** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( 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); + +/* +** CAPI3REF: Run-Time Library Compilation Options Diagnostics +** +** ^The sqlite3_compileoption_used() function returns 0 or 1 +** indicating whether the specified option was defined at +** compile time. ^The SQLITE_ prefix may be omitted from the +** option name passed to sqlite3_compileoption_used(). +** +** ^The sqlite3_compileoption_get() function allows iterating +** over the list of options that were defined at compile time by +** returning the N-th compile time option string. ^If N is out of range, +** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ +** prefix is omitted from any strings returned by +** sqlite3_compileoption_get(). +** +** ^Support for the diagnostic functions sqlite3_compileoption_used() +** and sqlite3_compileoption_get() may be omitted by specifying the +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. +** +** See also: SQL functions [sqlite_compileoption_used()] and +** [sqlite_compileoption_get()] and the [compile_options pragma]. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_API int sqlite3_compileoption_used(const char *zOptName); +SQLITE_API const char *sqlite3_compileoption_get(int N); +#endif + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe +** +** ^The sqlite3_threadsafe() function returns zero if and only if +** SQLite was compiled with mutexing code omitted due to the +** [SQLITE_THREADSAFE] compile-time option being set to 0. +** +** SQLite can be compiled with or without mutexes. When +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes +** are enabled and SQLite is threadsafe. When the +** [SQLITE_THREADSAFE] macro is 0, +** the mutexes are omitted. Without the mutexes, it is not safe +** to use SQLite concurrently from more than one thread. +** +** Enabling mutexes incurs a measurable performance penalty. +** So if speed is of utmost importance, it makes sense to disable +** the mutexes. But for maximum safety, mutexes should be enabled. +** ^The default behavior is for mutexes to be enabled. +** +** This interface can be used by an application to make sure that the +** version of SQLite that it is linking against was compiled with +** the desired setting of the [SQLITE_THREADSAFE] macro. +** +** This interface only reports on the compile-time mutex setting +** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but +** can be fully or partially disabled using a call to [sqlite3_config()] +** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], +** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the +** sqlite3_threadsafe() function shows only the compile-time setting of +** thread safety, not any run-time changes to that setting made by +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() +** is unchanged by calls to sqlite3_config().)^ +** +** See the [threading mode] documentation for additional information. +*/ +SQLITE_API int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle +** KEYWORDS: {database connection} {database connections} +** +** Each open SQLite database is represented by a pointer to an instance of +** the opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as +** [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on an +** sqlite3 object. +*/ +typedef struct sqlite3 sqlite3; + +/* +** CAPI3REF: 64-Bit Integer Types +** KEYWORDS: sqlite_int64 sqlite_uint64 +** +** Because there is no cross-platform way to specify 64-bit integer types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +** The sqlite_int64 and sqlite_uint64 types are supported for backwards +** compatibility only. +** +** ^The sqlite3_int64 and sqlite_int64 types can store integer values +** between -9223372036854775808 and +9223372036854775807 inclusive. ^The +** sqlite3_uint64 and sqlite_uint64 types can store integer values +** between 0 and +18446744073709551615 inclusive. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + 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 +** DESTRUCTOR: sqlite3 +** +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. +** +** ^If the database connection is associated with unfinalized prepared +** statements or unfinished sqlite3_backup objects then sqlite3_close() +** will leave the database connection open and return [SQLITE_BUSY]. +** ^If sqlite3_close_v2() is called with unfinalized prepared statements +** and/or unfinished sqlite3_backups, then the database connection becomes +** an unusable "zombie" which will automatically be deallocated when the +** last prepared statement is finalized or the last sqlite3_backup is +** finished. The sqlite3_close_v2() interface is intended for use with +** host languages that are garbage collected, and where the order in which +** destructors are called is arbitrary. +** +** Applications should [sqlite3_finalize | finalize] all [prepared statements], +** [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. ^If +** sqlite3_close_v2() is called on a [database connection] that still has +** outstanding [prepared statements], [BLOB handles], and/or +** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation +** of resources is deferred until all [prepared statements], [BLOB handles], +** and [sqlite3_backup] objects are also destroyed. +** +** ^If an [sqlite3] object is destroyed while a transaction is open, +** the transaction is automatically rolled back. +** +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL +** pointer or an [sqlite3] object pointer obtained +** from [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()], and not previously closed. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. +*/ +SQLITE_API int sqlite3_close(sqlite3*); +SQLITE_API int sqlite3_close_v2(sqlite3*); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface +** METHOD: sqlite3 +** +** The sqlite3_exec() interface is a convenience wrapper around +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], +** that allows an application to run multiple statements of SQL +** without having to use a lot of C code. +** +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, +** semicolon-separate SQL statements passed into its 2nd argument, +** in the context of the [database connection] passed in as its 1st +** argument. ^If the callback function of the 3rd argument to +** sqlite3_exec() is not NULL, then it is invoked for each result row +** coming out of the evaluated SQL statements. ^The 4th argument to +** sqlite3_exec() is relayed through to the 1st argument of each +** callback invocation. ^If the callback pointer to sqlite3_exec() +** is NULL, then no callback is ever invoked and result rows are +** ignored. +** +** ^If an error occurs while evaluating the SQL statements passed into +** sqlite3_exec(), then execution of the current statement stops and +** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() +** is not NULL then any error message is written into memory obtained +** from [sqlite3_malloc()] and passed back through the 5th parameter. +** To avoid memory leaks, the application should invoke [sqlite3_free()] +** on error message strings returned through the 5th parameter of +** sqlite3_exec() after the error message string is no longer needed. +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to +** NULL before returning. +** +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() +** routine returns SQLITE_ABORT without invoking the callback again and +** without running any subsequent SQL statements. +** +** ^The 2nd argument to the sqlite3_exec() callback function is the +** number of columns in the result. ^The 3rd argument to the sqlite3_exec() +** callback is an array of pointers to strings obtained as if from +** [sqlite3_column_text()], one for each column. ^If an element of a +** result row is NULL then the corresponding string pointer for the +** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the +** sqlite3_exec() callback is an array of pointers to strings where each +** entry represents the name of corresponding result column as obtained +** from [sqlite3_column_name()]. +** +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer +** to an empty string, or a pointer that contains only whitespace and/or +** SQL comments, then no SQL statements are evaluated and the database +** is not changed. +** +** Restrictions: +** +**
    +**
  • The application must ensure that the 1st parameter to sqlite3_exec() +** is a valid and open [database connection]. +**
  • The application must not close the [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: {result code definitions} +** +** Many SQLite functions return an integer result code from the set shown +** here in order to indicate success or failure. +** +** New error codes may be added in future versions of SQLite. +** +** See also: [extended result code definitions] +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */ +#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes +** KEYWORDS: {extended result code definitions} +** +** In its default configuration, SQLite API routines return one of 30 integer +** [result codes]. However, experience has shown that many of +** these result codes are too coarse-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8] +** and later) include +** support for additional result codes that provide more detailed information +** about errors. These [extended result codes] are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. Or, the extended code for +** the most recent error can be obtained using +** [sqlite3_extended_errcode()]. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) +#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) +#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) +#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) +#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) +#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) +#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) +#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) +#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) +#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) +#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) +#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8)) +#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) +#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) +#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) +#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) +#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) +#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) +#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) +#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) +#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) +#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) +#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) +#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) +#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8)) + +/* +** CAPI3REF: Flags For File Open Operations +** +** These bit values are intended for use in the +** 3rd parameter to the [sqlite3_open_v2()] interface and +** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ +#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ +#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ +#define SQLITE_OPEN_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() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ + +/* Reserved: 0x00F00000 */ + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +** flag indicate that a file cannot be deleted when open. The +** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +** read-only media and cannot be changed even by processes with +** elevated privileges. +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 +#define SQLITE_IOCAP_IMMUTABLE 0x00002000 + +/* +** CAPI3REF: File Locking Levels +** +** SQLite uses one of these integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags +** +** When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of +** these integer values as the second argument. +** +** When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. If the lower four bits of the flag +** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +** If the lower four bits equal SQLITE_SYNC_FULL, that means +** to use Mac OS X style fullsync instead of fsync(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** An [sqlite3_file] object represents an open file in the +** [sqlite3_vfs | OS interface layer]. Individual OS interface +** implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object +** +** Every file opened by the [sqlite3_vfs.xOpen] method populates an +** [sqlite3_file] object (or, more commonly, a subclass of the +** [sqlite3_file] object) with a pointer to an instance of this object. +** This object defines the methods used to perform various operations +** against the open file represented by the [sqlite3_file] object. +** +** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +** to a non-NULL pointer, then the sqlite3_io_methods.xClose method +** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +** to NULL. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +** flag may be ORed in to indicate that only the data of the file +** and not its inode needs to be synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [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 [file control opcodes | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [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*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); + int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p); + /* Methods above are valid for version 3 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** KEYWORDS: {file control opcodes} {file control opcode} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +**
    +**
  • [[SQLITE_FCNTL_LOCKSTATE]] +** 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 is only available when the SQLITE_TEST +** compile-time option is used. +** +**
  • [[SQLITE_FCNTL_SIZE_HINT]] +** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS +** layer a hint of how large the database file will grow to be during the +** current transaction. This hint is not guaranteed to be accurate but it +** is often close. The underlying VFS might choose to preallocate database +** file space based on this hint in order to help writes to the database +** file run faster. +** +**
  • [[SQLITE_FCNTL_CHUNK_SIZE]] +** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS +** extends and truncates the database file in chunks of a size specified +** by the user. The fourth argument to [sqlite3_file_control()] should +** point to an integer (type int) containing the new chunk-size to use +** for the nominated database. Allocating database file space in large +** chunks (say 1MB at a time), may reduce file-system fragmentation and +** improve performance on some systems. +** +**
  • [[SQLITE_FCNTL_FILE_POINTER]] +** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with a particular database +** connection. See also [SQLITE_FCNTL_JOURNAL_POINTER]. +** +**
  • [[SQLITE_FCNTL_JOURNAL_POINTER]] +** The [SQLITE_FCNTL_JOURNAL_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with the journal file (either +** the [rollback journal] or the [write-ahead log]) for a particular database +** connection. See also [SQLITE_FCNTL_FILE_POINTER]. +** +**
  • [[SQLITE_FCNTL_SYNC_OMITTED]] +** No longer in use. +** +**
  • [[SQLITE_FCNTL_SYNC]] +** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and +** sent to the VFS immediately before the xSync method is invoked on a +** database file descriptor. Or, if the xSync method is not invoked +** because the user has configured SQLite with +** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place +** of the xSync method. In most cases, the pointer argument passed with +** this file-control is NULL. However, if the database file is being synced +** as part of a multi-database commit, the argument points to a nul-terminated +** string containing the transactions master-journal file name. VFSes that +** do not need this signal should silently ignore this opcode. Applications +** should not call [sqlite3_file_control()] with this opcode as doing so may +** disrupt the operation of the specialized VFSes that do require it. +** +**
  • [[SQLITE_FCNTL_COMMIT_PHASETWO]] +** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite +** and sent to the VFS after a transaction has been committed immediately +** but before the database is unlocked. VFSes that do not need this signal +** should silently ignore this opcode. Applications should not call +** [sqlite3_file_control()] with this opcode as doing so may disrupt the +** operation of the specialized VFSes that do require it. +** +**
  • [[SQLITE_FCNTL_WIN32_AV_RETRY]] +** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic +** retry counts and intervals for certain disk I/O operations for the +** windows [VFS] in order to provide robustness in the presence of +** anti-virus programs. By default, the windows VFS will retry file read, +** file write, and file delete operations up to 10 times, with a delay +** of 25 milliseconds before the first retry and with the delay increasing +** by an additional 25 milliseconds with each subsequent retry. This +** opcode allows these two values (10 retries and 25 milliseconds of delay) +** to be adjusted. The values are changed for all database connections +** within the same process. The argument is a pointer to an array of two +** integers where the first integer i the new retry count and the second +** integer is the delay. If either integer is negative, then the setting +** is not changed but instead the prior value of that setting is written +** into the array entry, allowing the current retry settings to be +** interrogated. The zDbName parameter is ignored. +** +**
  • [[SQLITE_FCNTL_PERSIST_WAL]] +** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the +** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary +** write ahead log and shared memory files used for transaction control +** are automatically deleted when the latest connection to the database +** closes. Setting persistent WAL mode causes those files to persist after +** close. Persisting the files is useful when other processes that do not +** have write permission on the directory containing the database file want +** to read the database file, as the WAL and shared memory files must exist +** in order for the database to be readable. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable persistent WAL mode or 1 to enable persistent +** WAL mode. If the integer is -1, then it is overwritten with the current +** WAL persistence setting. +** +**
  • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] +** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the +** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting +** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the +** xDeviceCharacteristics methods. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage +** mode. If the integer is -1, then it is overwritten with the current +** zero-damage mode setting. +** +**
  • [[SQLITE_FCNTL_OVERWRITE]] +** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening +** a write transaction to indicate that, unless it is rolled back for some +** reason, the entire database file will be overwritten by the current +** transaction. This is used by VACUUM operations. +** +**
  • [[SQLITE_FCNTL_VFSNAME]] +** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of +** all [VFSes] in the VFS stack. The names are of all VFS shims and the +** final bottom-level VFS are written into memory obtained from +** [sqlite3_malloc()] and the result is stored in the char* variable +** that the fourth parameter of [sqlite3_file_control()] points to. +** The caller is responsible for freeing the memory when done. As with +** all file-control actions, there is no guarantee that this will actually +** do anything. Callers should initialize the char* variable to a NULL +** pointer in case this file-control is not implemented. This file-control +** is intended for diagnostic use only. +** +**
  • [[SQLITE_FCNTL_VFS_POINTER]] +** ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level +** [VFSes] currently in use. ^(The argument X in +** sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be +** of type "[sqlite3_vfs] **". This opcodes will set *X +** to a pointer to the top-level VFS.)^ +** ^When there are multiple VFS shims in the stack, this opcode finds the +** upper-most shim only. +** +**
  • [[SQLITE_FCNTL_PRAGMA]] +** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA] +** file control is sent to the open [sqlite3_file] object corresponding +** to the database file to which the pragma statement refers. ^The argument +** to the [SQLITE_FCNTL_PRAGMA] file control is an array of +** pointers to strings (char**) in which the second element of the array +** is the name of the pragma and the third element is the argument to the +** pragma or NULL if the pragma has no argument. ^The handler for an +** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element +** of the char** argument point to a string obtained from [sqlite3_mprintf()] +** or the equivalent and that string will become the result of the pragma or +** the error message if the pragma fails. ^If the +** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal +** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] +** file control returns [SQLITE_OK], then the parser assumes that the +** VFS has handled the PRAGMA itself and the parser generates a no-op +** prepared statement if result string is NULL, or that returns a copy +** of the result string if the string is non-NULL. +** ^If the [SQLITE_FCNTL_PRAGMA] file control returns +** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means +** that the VFS encountered an error while handling the [PRAGMA] and the +** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] +** file control occurs at the beginning of pragma statement analysis and so +** it is able to override built-in [PRAGMA] statements. +** +**
  • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^The [SQLITE_FCNTL_BUSYHANDLER] +** file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connections busy-handler callback. The argument is of type (void **) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connections +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
  • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control +** to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** +**
  • [[SQLITE_FCNTL_MMAP_SIZE]] +** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the +** maximum number of bytes that will be used for memory-mapped I/O. +** The argument is a pointer to a value of type sqlite3_int64 that +** is an advisory maximum number of bytes in the file to memory map. The +** pointer is overwritten with the old value. The limit is not changed if +** the value originally pointed to is negative, and so the current limit +** can be queried by passing in a pointer to a negative number. This +** file-control is used internally to implement [PRAGMA mmap_size]. +** +**
  • [[SQLITE_FCNTL_TRACE]] +** The [SQLITE_FCNTL_TRACE] file control provides advisory information +** to the VFS about what the higher layers of the SQLite stack are doing. +** This file control is used by some VFS activity tracing [shims]. +** The argument is a zero-terminated string. Higher layers in the +** SQLite stack may generate instances of this file control if +** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled. +** +**
  • [[SQLITE_FCNTL_HAS_MOVED]] +** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a +** pointer to an integer and it writes a boolean into that integer depending +** on whether or not the file has been renamed, moved, or deleted since it +** was first opened. +** +**
  • [[SQLITE_FCNTL_WIN32_GET_HANDLE]] +** The [SQLITE_FCNTL_WIN32_GET_HANDLE] opcode can be used to obtain the +** underlying native file handle associated with a file handle. This file +** control interprets its argument as a pointer to a native file handle and +** writes the resulting value there. +** +**
  • [[SQLITE_FCNTL_WIN32_SET_HANDLE]] +** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging. This +** opcode causes the xFileControl method to swap the file handle with the one +** pointed to by the pArg argument. This capability is used during testing +** and only needs to be supported when SQLITE_TEST is defined. +** +**
  • [[SQLITE_FCNTL_WAL_BLOCK]] +** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might +** be advantageous to block on the next WAL lock if the lock is not immediately +** available. The WAL subsystem issues this signal during rare +** circumstances in order to fix a problem with priority inversion. +** Applications should not use this file-control. +** +**
  • [[SQLITE_FCNTL_ZIPVFS]] +** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other +** VFS should return SQLITE_NOTFOUND for this opcode. +** +**
  • [[SQLITE_FCNTL_RBU]] +** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by +** the RBU extension only. All other VFS should return SQLITE_NOTFOUND for +** this opcode. +**
+*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 +#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 +#define SQLITE_FCNTL_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNT... (445 KB left) \ No newline at end of file