/library/Library/WP7/SQLiteDriver/sqlite/sqlite3_h.cs

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