/drivers/sqlite-wp7/sqlite/sqlite3_h.cs
C# | 6931 lines | 559 code | 195 blank | 6177 comment | 1 complexity | 9e04f0da16d31674651fb379356f4e22 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- using u8 = System.Byte;
- using System.Diagnostics;
- namespace Community.CsharpSqlite
- {
- public partial class Sqlite3
- {
- /*
- ** 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.
- *************************************************************************
- ** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
- ** C#-SQLite is an independent reimplementation of the SQLite software library
- **
- ** SQLITE_SOURCE_ID: 2011-01-28 17:03:50 ed759d5a9edb3bba5f48f243df47be29e3fe8cd7
- **
- *************************************************************************
- */
- //#ifndef _SQLITE3_H_
- //#define _SQLITE3_H_
- //#include <stdarg.h> /* Needed for the definition of va_list */
- /*
- ** Make sure we can call this stuff from C++.
- */
- //#ifdef __cplusplus
- //extern "C" {
- //#endif
- /*
- ** Add the ability to override 'extern'
- */
- //#ifndef SQLITE_EXTERN
- //# define SQLITE_EXTERN extern
- //#endif
- //#ifndef SQLITE_API
- //# define SQLITE_API
- //#endif
- /*
- ** These no-op macros are used in front of interfaces to mark those
- ** interfaces as either deprecated or experimental. New applications
- ** should not use deprecated interfaces - they are support for backwards
- ** compatibility only. Application writers should be aware that
- ** experimental interfaces are subject to change in point releases.
- **
- ** These macros used to resolve to various kinds of compiler magic that
- ** would generate warning messages when they were used. But that
- ** compiler magic ended up generating such a flurry of bug reports
- ** that we have taken it all out and gone back to using simple
- ** noop macros.
- */
- //#define SQLITE_DEPRECATED
- //#define SQLITE_EXPERIMENTAL
- /*
- ** Ensure these symbols were not defined by some previous header file.
- */
- //#ifdef SQLITE_VERSION
- //# undef SQLITE_VERSION
- //#endif
- //#ifdef SQLITE_VERSION_NUMBER
- //# undef SQLITE_VERSION_NUMBER
- //#endif
- /*
- ** CAPI3REF: Compile-Time Library Version Numbers
- **
- ** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
- ** evaluates to a string literal that is the SQLite version in the
- ** format "X.Y.Z" where X is the major version number (always 3 for
- ** SQLite3) and Y is the minor version number and Z is the release number.)^
- ** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
- ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
- ** numbers used in [SQLITE_VERSION].)^
- ** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
- ** be larger than the release from which it is derived. Either Y will
- ** be held constant and Z will be incremented or else Y will be incremented
- ** and Z will be reset to zero.
- **
- ** Since version 3.6.18, SQLite source code has been stored in the
- ** <a href="http://www.fossil-scm.org/">Fossil configuration management
- ** system</a>. ^The SQLITE_SOURCE_ID macro evaluates to
- ** a string which identifies a particular check-in of SQLite
- ** within its configuration management system. ^The SQLITE_SOURCE_ID
- ** string contains the date and time of the check-in (UTC) and an SHA1
- ** hash of the entire source tree.
- **
- ** See also: [sqlite3_libversion()],
- ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
- ** [sqlite_version()] and [sqlite_source_id()].
- */
- //#define SQLITE_VERSION "3.7.5"
- //#define SQLITE_VERSION_NUMBER 3007005
- //#define SQLITE_SOURCE_ID "2011-01-28 17:03:50 ed759d5a9edb3bba5f48f243df47be29e3fe8cd7"
- const string SQLITE_VERSION = "3.7.5.C#";
- const int SQLITE_VERSION_NUMBER = 300700567;
- const string SQLITE_SOURCE_ID = "Ported to C# from 2011-01-28 17:03:50 ed759d5a9edb3bba5f48f243df47be29e3fe8cd7";
- /*
- ** CAPI3REF: Run-Time Library Version Numbers
- ** KEYWORDS: sqlite3_version, sqlite3_sourceid
- **
- ** These interfaces provide the same information as the [SQLITE_VERSION],
- ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
- ** but are associated with the library instead of the header file. ^(Cautious
- ** programmers might include assert() statements in their application to
- ** verify that values returned by these interfaces match the macros in
- ** the header, and thus insure that the application is
- ** compiled with matching library and header files.
- **
- ** <blockquote><pre>
- ** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
- ** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
- ** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
- ** </pre></blockquote>)^
- **
- ** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
- ** macro. ^The sqlite3_libversion() function returns a pointer to the
- ** to the sqlite3_version[] string constant. The sqlite3_libversion()
- ** function is provided for use in DLLs since DLL users usually do not have
- ** direct access to string constants within the DLL. ^The
- ** sqlite3_libversion_number() function returns an integer equal to
- ** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns
- ** a pointer to a string constant whose value is the same as the
- ** [SQLITE_SOURCE_ID] C preprocessor macro.
- **
- ** See also: [sqlite_version()] and [sqlite_source_id()].
- */
- //SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
- //SQLITE_API const char *sqlite3_libversion(void);
- //SQLITE_API const char *sqlite3_sourceid(void);
- //SQLITE_API int sqlite3_libversion_number(void);
- /*
- ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
- **
- ** ^The sqlite3_compileoption_used() function returns 0 or 1
- ** indicating whether the specified option was defined at
- ** compile time. ^The SQLITE_ prefix may be omitted from the
- ** option name passed to sqlite3_compileoption_used().
- **
- ** ^The sqlite3_compileoption_get() function allows iterating
- ** over the list of options that were defined at compile time by
- ** returning the N-th compile time option string. ^If N is out of range,
- ** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_
- ** prefix is omitted from any strings returned by
- ** sqlite3_compileoption_get().
- **
- ** ^Support for the diagnostic functions sqlite3_compileoption_used()
- ** and sqlite3_compileoption_get() may be omitted by specifying the
- ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
- **
- ** See also: SQL functions [sqlite_compileoption_used()] and
- ** [sqlite_compileoption_get()] and the [compile_options pragma].
- */
- //#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
- //SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
- //SQLITE_API const char *sqlite3_compileoption_get(int N);
- //#endif
- /*
- ** CAPI3REF: Test To See If The Library Is Threadsafe
- **
- ** ^The sqlite3_threadsafe() function returns zero if and only if
- ** SQLite was compiled 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
- ** successfully 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:
- **
- ** <ul>
- ** <li> The application must insure that the 1st parameter to sqlite3_exec()
- ** is a valid and open [database connection].
- ** <li> The application must not close [database connection] specified by
- ** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
- ** <li> The application must not modify the SQL statement text passed into
- ** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
- ** </ul>
- */
- //SQLITE_API int sqlite3_exec(
- // sqlite3*, /* An open database */
- // const char *sql, /* SQL to be evaluated */
- // int (*callback)(void*,int,char**,char**), /* Callback function */
- // void *, /* 1st argument to callback */
- // char **errmsg /* Error msg written here */
- //);
- /*
- ** CAPI3REF: Result Codes
- ** KEYWORDS: SQLITE_OK {error code} {error codes}
- ** KEYWORDS: {result code} {result codes}
- **
- ** Many SQLite functions return an integer result code from the set shown
- ** here in order to 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 /* Unknown opcode in sqlite3_file_control() */
- //#define SQLITE_FULL 13 /* Insertion failed because database is full */
- //#define SQLITE_CANTOPEN 14 /* Unable to open the database file */
- //#define SQLITE_PROTOCOL 15 /* Database lock protocol error */
- //#define SQLITE_EMPTY 16 /* Database is empty */
- //#define SQLITE_SCHEMA 17 /* The database schema changed */
- //#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
- //#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */
- //#define SQLITE_MISMATCH 20 /* Data type mismatch */
- //#define SQLITE_MISUSE 21 /* Library used incorrectly */
- //#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
- //#define SQLITE_AUTH 23 /* Authorization denied */
- //#define SQLITE_FORMAT 24 /* Auxiliary database format error */
- //#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
- //#define SQLITE_NOTADB 26 /* File opened that is not a database file */
- //#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */
- //#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */
- /* end-of-error-codes */
- public const int SQLITE_OK = 0;
- public const int SQLITE_ERROR = 1;
- public const int SQLITE_INTERNAL = 2;
- public const int SQLITE_PERM = 3;
- public const int SQLITE_ABORT = 4;
- public const int SQLITE_BUSY = 5;
- public const int SQLITE_LOCKED = 6;
- public const int SQLITE_NOMEM = 7;
- public const int SQLITE_READONLY = 8;
- public const int SQLITE_INTERRUPT = 9;
- public const int SQLITE_IOERR = 10;
- public const int SQLITE_CORRUPT = 11;
- public const int SQLITE_NOTFOUND = 12;
- public const int SQLITE_FULL = 13;
- public const int SQLITE_CANTOPEN = 14;
- public const int SQLITE_PROTOCOL = 15;
- public const int SQLITE_EMPTY = 16;
- public const int SQLITE_SCHEMA = 17;
- public const int SQLITE_TOOBIG = 18;
- public const int SQLITE_CONSTRAINT = 19;
- public const int SQLITE_MISMATCH = 20;
- public const int SQLITE_MISUSE = 21;
- public const int SQLITE_NOLFS = 22;
- public const int SQLITE_AUTH = 23;
- public const int SQLITE_FORMAT = 24;
- public const int SQLITE_RANGE = 25;
- public const int SQLITE_NOTADB = 26;
- public const int SQLITE_ROW = 100;
- public const int SQLITE_DONE = 101;
- /*
- ** CAPI3REF: Extended Result Codes
- ** KEYWORDS: {extended error code} {extended error codes}
- ** KEYWORDS: {extended result code} {extended result codes}
- **
- ** In its default configuration, SQLite API routines return one of 26 integer
- ** [SQLITE_OK | result codes]. However, experience has shown that many of
- ** these result codes are too coarse-grained. They do not provide as
- ** much information about problems as programmers might like. In an effort to
- ** address this, newer versions of SQLite (version 3.3.8 and later) include
- ** support for additional result codes that provide more detailed information
- ** about errors. The extended result codes are enabled or disabled
- ** on a per database connection basis using the
- ** [sqlite3_extended_result_codes()] API.
- **
- ** Some of the available extended result codes are listed here.
- ** One may expect the number of extended result codes will be expand
- ** over time. Software that uses extended result codes should expect
- ** to see new result codes in future releases of SQLite.
- **
- ** The SQLITE_OK result code will never be extended. It will always
- ** be exactly zero.
- */
- //#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))
- //#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))
- //#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))
- //#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))
- //#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))
- //#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))
- //#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))
- //#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))
- //#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))
- //#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))
- //#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))
- //#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))
- //#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))
- //#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
- //#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))
- //#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))
- //#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))
- //#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))
- //#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))
- //#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))
- //#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))
- //#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))
- //#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))
- const int SQLITE_IOERR_READ = ( SQLITE_IOERR | ( 1 << 8 ) );
- const int SQLITE_IOERR_SHORT_READ = ( SQLITE_IOERR | ( 2 << 8 ) );
- const int SQLITE_IOERR_WRITE = ( SQLITE_IOERR | ( 3 << 8 ) );
- const int SQLITE_IOERR_FSYNC = ( SQLITE_IOERR | ( 4 << 8 ) );
- const int SQLITE_IOERR_DIR_FSYNC = ( SQLITE_IOERR | ( 5 << 8 ) );
- const int SQLITE_IOERR_TRUNCATE = ( SQLITE_IOERR | ( 6 << 8 ) );
- const int SQLITE_IOERR_FSTAT = ( SQLITE_IOERR | ( 7 << 8 ) );
- const int SQLITE_IOERR_UNLOCK = ( SQLITE_IOERR | ( 8 << 8 ) );
- const int SQLITE_IOERR_RDLOCK = ( SQLITE_IOERR | ( 9 << 8 ) );
- const int SQLITE_IOERR_DELETE = ( SQLITE_IOERR | ( 10 << 8 ) );
- const int SQLITE_IOERR_BLOCKED = ( SQLITE_IOERR | ( 11 << 8 ) );
- const int SQLITE_IOERR_NOMEM = ( SQLITE_IOERR | ( 12 << 8 ) );
- const int SQLITE_IOERR_ACCESS = ( SQLITE_IOERR | ( 13 << 8 ) );
- const int SQLITE_IOERR_CHECKRESERVEDLOCK = ( SQLITE_IOERR | ( 14 << 8 ) );
- const int SQLITE_IOERR_LOCK = ( SQLITE_IOERR | ( 15 << 8 ) );
- const int SQLITE_IOERR_CLOSE = ( SQLITE_IOERR | ( 16 << 8 ) );
- const int SQLITE_IOERR_DIR_CLOSE = ( SQLITE_IOERR | ( 17 << 8 ) );
- const int SQLITE_IOERR_SHMOPEN = ( SQLITE_IOERR | ( 18 << 8 ) );
- const int SQLITE_IOERR_SHMSIZE = ( SQLITE_IOERR | ( 19 << 8 ) );
- const int SQLITE_IOERR_SHMLOCK = ( SQLITE_IOERR | ( 20 << 8 ) );
- const int SQLITE_LOCKED_SHAREDCACHE = ( SQLITE_LOCKED | ( 1 << 8 ) );
- const int SQLITE_BUSY_RECOVERY = ( SQLITE_BUSY | ( 1 << 8 ) );
- const int SQLITE_CANTOPEN_NOTEMPDIR = ( SQLITE_CANTOPEN | ( 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() */
- //#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
- /* Reserved: 0x00F00000 */
- public const int SQLITE_OPEN_READONLY = 0x00000001;
- public const int SQLITE_OPEN_READWRITE = 0x00000002;
- public const int SQLITE_OPEN_CREATE = 0x00000004;
- public const int SQLITE_OPEN_DELETEONCLOSE = 0x00000008;
- public const int SQLITE_OPEN_EXCLUSIVE = 0x00000010;
- public const int SQLITE_OPEN_AUTOPROXY = 0x00000020;
- public const int SQLITE_OPEN_MAIN_DB = 0x00000100;
- public const int SQLITE_OPEN_TEMP_DB = 0x00000200;
- public const int SQLITE_OPEN_TRANSIENT_DB = 0x00000400;
- public const int SQLITE_OPEN_MAIN_JOURNAL = 0x00000800;
- public const int SQLITE_OPEN_TEMP_JOURNAL = 0x00001000;
- public const int SQLITE_OPEN_SUBJOURNAL = 0x00002000;
- public const int SQLITE_OPEN_MASTER_JOURNAL = 0x00004000;
- public const int SQLITE_OPEN_NOMUTEX = 0x00008000;
- public const int SQLITE_OPEN_FULLMUTEX = 0x00010000;
- public const int SQLITE_OPEN_SHAREDCACHE = 0x00020000;
- public const int SQLITE_OPEN_PRIVATECACHE = 0x00040000;
- public const int SQLITE_OPEN_WAL = 0x00080000;
- /*
- ** CAPI3REF: Device Characteristics
- **
- ** The xDeviceCharacteristics 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
- //#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800
- const int SQLITE_IOCAP_ATOMIC = 0x00000001;
- const int SQLITE_IOCAP_ATOMIC512 = 0x00000002;
- const int SQLITE_IOCAP_ATOMIC1K = 0x00000004;
- const int SQLITE_IOCAP_ATOMIC2K = 0x00000008;
- const int SQLITE_IOCAP_ATOMIC4K = 0x00000010;
- const int SQLITE_IOCAP_ATOMIC8K = 0x00000020;
- const int SQLITE_IOCAP_ATOMIC16K = 0x00000040;
- const int SQLITE_IOCAP_ATOMIC32K = 0x00000080;
- const int SQLITE_IOCAP_ATOMIC64K = 0x00000100;
- const int SQLITE_IOCAP_SAFE_APPEND = 0x00000200;
- const int SQLITE_IOCAP_SEQUENTIAL = 0x00000400;
- const int SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = 0x00000800;
- /*
- ** 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
- const int SQLITE_LOCK_NONE = 0;
- const int SQLITE_LOCK_SHARED = 1;
- const int SQLITE_LOCK_RESERVED = 2;
- const int SQLITE_LOCK_PENDING = 3;
- const int 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
- const int SQLITE_SYNC_NORMAL = 0x00002;
- const int SQLITE_SYNC_FULL = 0x00003;
- const int 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 */
- //};
- public partial class sqlite3_file
- {
- public sqlite3_io_methods pMethods;/* Must be first */
- }
- /*
- ** 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
- ** <ul>
- ** <li> [SQLITE_LOCK_NONE],
- ** <li> [SQLITE_LOCK_SHARED],
- ** <li> [SQLITE_LOCK_RESERVED],
- ** <li> [SQLITE_LOCK_PENDING], or
- ** <li> [SQLITE_LOCK_EXCLUSIVE].
- ** </ul>
- ** xLock() increases the lock. xUnlock() decreases the lock.
- ** The xCheckReservedLock() method checks whether any database connection,
- ** either in this process or in some other process, is holding a RESERVED,
- ** PENDING, or EXCLUSIVE lock on the file. It returns true
- ** if such a lock exists and false otherwise.
- **
- ** The xFileControl() method is a generic interface that allows custom
- ** VFS implementations to directly control an open file using the
- ** [sqlite3_file_control()] interface. The second "op" argument is an
- ** integer opcode. The third argument is a generic pointer intended to
- ** point to a structure that may contain arguments or space in which to
- ** write return values. Potential uses for xFileControl() might be
- ** functions to enable blocking locks with timeouts, to change the
- ** locking strategy (for example to use dot-file locks), to inquire
- ** about the status of a lock, or to break stale locks. The SQLite
- ** core reserves all opcodes less than 100 for its own use.
- ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
- ** Applications that define a custom xFileControl method should use opcodes
- ** greater than 100 to avoid conflicts. 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:
- **
- ** <ul>
- ** <li> [SQLITE_IOCAP_ATOMIC]
- ** <li> [SQLITE_IOCAP_ATOMIC512]
- ** <li> [SQLITE_IOCAP_ATOMIC1K]
- ** <li> [SQLITE_IOCAP_ATOMIC2K]
- ** <li> [SQLITE_IOCAP_ATOMIC4K]
- ** <li> [SQLITE_IOCAP_ATOMIC8K]
- ** <li> [SQLITE_IOCAP_ATOMIC16K]
- ** <li> [SQLITE_IOCAP_ATOMIC32K]
- ** <li> [SQLITE_IOCAP_ATOMIC64K]
- ** <li> [SQLITE_IOCAP_SAFE_APPEND]
- ** <li> [SQLITE_IOCAP_SEQUENTIAL]
- ** </ul>
- **
- ** The SQLITE_IOCAP_ATOMIC property means that all writes of
- ** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values
- ** mean that writes of blocks that are nnn bytes in size and
- ** are aligned to an address which is an integer multiple of
- ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
- ** that when data is appended to a file, the data is appended
- ** first then the size of the file is extended, never the other
- ** way around. The SQLITE_IOCAP_SEQUENTIAL property means that
- ** information is written to disk in the same order as calls
- ** to xWrite().
- **
- ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
- ** in the unread portions of the buffer with zeros. A VFS that
- ** fails to zero-fill short reads might seem to work. However,
- ** failure to zero-fill short reads will eventually lead to
- ** database corruption.
- */
- //typedef struct sqlite3_io_methods sqlite3_io_methods;
- //struct sqlite3_io_methods {
- // int iVersion;
- // int (*xClose)(sqlite3_file*);
- // int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
- // int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
- // int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
- // int (*xSync)(sqlite3_file*, int flags);
- // int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
- // int (*xLock)(sqlite3_file*, int);
- // int (*xUnlock)(sqlite3_file*, int);
- // int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);
- // int (*xFileControl)(sqlite3_file*, int op, void *pArg);
- // int (*xSectorSize)(sqlite3_file*);
- // int (*xDeviceCharacteristics)(sqlite3_file*);
- // /* 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 */
- // /* Additional methods may be added in future releases */
- //};
- public class sqlite3_io_methods
- {
- public int iVersion;
- public dxClose xClose;
- public dxRead xRead;
- public dxWrite xWrite;
- public dxTruncate xTruncate;
- public dxSync xSync;
- public dxFileSize xFileSize;
- public dxLock xLock;
- public dxUnlock xUnlock;
- public dxCheckReservedLock xCheckReservedLock;
- public dxFileControl xFileControl;
- public dxSectorSize xSectorSize;
- public dxDeviceCharacteristics xDeviceCharacteristics;
- public dxShmMap xShmMap;//int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
- public dxShmLock xShmLock;//int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
- public dxShmBarrier xShmBarrier;//void (*xShmBarrier)(sqlite3_file*);
- public dxShmUnmap xShmUnmap;//int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
- /* Additional methods may be added in future releases */
- public sqlite3_io_methods( int iVersion,
- dxClose xClose,
- dxRead xRead,
- dxWrite xWrite,
- dxTruncate xTruncate,
- dxSync xSync,
- dxFileSize xFileSize,
- dxLock xLock,
- dxUnlock xUnlock,
- dxCheckReservedLock xCheckReservedLock,
- dxFileControl xFileControl,
- dxSectorSize xSectorSize,
- dxDeviceCharacteristics xDeviceCharacteristics,
- dxShmMap xShmMap,
- dxShmLock xShmLock,
- dxShmBarrier xShmBarrier,
- dxShmUnmap xShmUnmap
- )
- {
- this.iVersion = iVersion;
- this.xClose = xClose;
- this.xRead = xRead;
- this.xWrite = xWrite;
- this.xTruncate = xTruncate;
- this.xSync = xSync;
- this.xFileSize = xFileSize;
- this.xLock = xLock;
- this.xUnlock = xUnlock;
- this.xCheckReservedLock = xCheckReservedLock;
- this.xFileControl = xFileControl;
- this.xSectorSize = xSectorSize;
- this.xDeviceCharacteristics = xDeviceCharacteristics;
- this.xShmMap = xShmMap;
- this.xShmLock = xShmLock;
- this.xShmBarrier = xShmBarrier;
- this.xShmUnmap = xShmUnmap;
- }
- }
- /*
- ** 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.
- **
- ** 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.
- **
- ** 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.
- **
- ** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
- ** to the [sqlite3_file] object associated with a particular database
- ** connection. See the [sqlite3_file_control()] documentation for
- ** additional information.
- **
- ** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by
- ** SQLite and sent to all VFSes in place of a call to the xSync method
- ** when the database connection has [PRAGMA synchronous] set to OFF.)^
- ** Some specialized VFSes need this signal in order to operate correctly
- ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most
- ** VFSes do not need this signal and should silently ignore this opcode.
- ** Applications should not call [sqlite3_file_control()] with this
- ** opcode as doing so may disrupt the operation of the specilized VFSes
- ** that do require it.
- */
- //#define SQLITE_FCNTL_LOCKSTATE 1
- //#define SQLITE_GET_LOCKPROXYFILE 2
- //#define SQLITE_SET_LOCKPROXYFILE 3
- //#define SQLITE_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
- const int SQLITE_FCNTL_LOCKSTATE = 1;
- const int SQLITE_GET_LOCKPROXYFILE = 2;
- const int SQLITE_SET_LOCKPROXYFILE = 3;
- const int SQLITE_LAST_ERRNO = 4;
- const int SQLITE_FCNTL_SIZE_HINT = 5;
- const int SQLITE_FCNTL_CHUNK_SIZE = 6;
- const int SQLITE_FCNTL_FILE_POINTER = 7;
- const int SQLITE_FCNTL_SYNC_OMITTED = 8;
- /*
- ** 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 guarantees that the zFilename parameter to xOpen
- ** is either a NULL pointer or string obtained
- ** from xFullPathname() with an optional suffix added.
- ** ^If a suffix is added to the zFilename parameter, it will
- ** consist of a single "-" character followed by no more than
- ** 10 alphanumeric and/or "-" characters.
- ** ^SQLite further guarantees that
- ** the string will be valid and unchanged until xClose() is
- ** called. Because of the previous sentence,
- ** the [sqlite3_file] can safely store a pointer to the
- ** filename if it needs to remember the filename for some reason.
- ** If the zFilename parameter to xOpen is a NULL pointer then xOpen
- ** must invent its own temporary name for the file. ^Whenever the
- ** xFilename parameter is NULL it will also be the case that the
- ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
- **
- ** The flags argument to xOpen() includes all bits set in
- ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]
- ** or [sqlite3_open16()] is used, then flags includes at least
- ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
- ** If xOpen() opens a file read-only then it sets *pOutFlags to
- ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.
- **
- ** ^(SQLite will also add one of the following flags to the xOpen()
- ** call, depending on the object being opened:
- **
- ** <ul>
- ** <li> [SQLITE_OPEN_MAIN_DB]
- ** <li> [SQLITE_OPEN_MAIN_JOURNAL]
- ** <li> [SQLITE_OPEN_TEMP_DB]
- ** <li> [SQLITE_OPEN_TEMP_JOURNAL]
- ** <li> [SQLITE_OPEN_TRANSIENT_DB]
- ** <li> [SQLITE_OPEN_SUBJOURNAL]
- ** <li> [SQLITE_OPEN_MASTER_JOURNAL]
- ** <li> [SQLITE_OPEN_WAL]
- ** </ul>)^
- **
- ** The file I/O implementation can use the object type flags to
- ** change the way it deals with files. For example, an application
- ** that does not care about crash recovery or rollback might make
- ** the open of a journal file a no-op. Writes to this journal would
- ** also be no-ops, and any attempt to read the journal would return
- ** SQLITE_IOERR. Or the implementation might recognize that a database
- ** file will be doing page-aligned sector reads and writes in a random
- ** order and set up its I/O subsystem accordingly.
- **
- ** SQLite might also add one of the following flags to …
Large files files are truncated, but you can click here to view the full file