/*

 ** 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 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.

 **

 ** @(#) $Id: sqlite.h.in,v 1.387 2008/08/05 17:53:23 drh Exp $

 */

 #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

 /*

 ** 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 {H10010} <S60100>

 **

 ** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in

 ** the sqlite3.h file specify the version of SQLite with which

 ** that header file is associated.

 **

 ** The "version" of SQLite is a string of the form "X.Y.Z".

 ** The phrase "alpha" or "beta" might be appended after the Z.

 ** The X value is major version number always 3 in SQLite3.

 ** The X value only changes when backwards compatibility is

 ** broken and we intend to never break backwards compatibility.

 ** The Y value is the minor version number and only changes when

 ** there are major feature enhancements that are forwards compatible

 ** but not backwards compatible.

 ** The Z value is the release number and is incremented with

 ** each release but resets back to 0 whenever Y is incremented.

 **

 ** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()].

 **

 ** INVARIANTS:

 **

 ** {H10011} The SQLITE_VERSION #define in the sqlite3.h header file shall

 **          evaluate to a string literal that is the SQLite version

 **          with which the header file is associated.

 **

 ** {H10014} The SQLITE_VERSION_NUMBER #define shall resolve to an integer

 **          with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z

 **          are the major version, minor version, and release number.

 */

 #define SQLITE_VERSION         "3.6.1"

 #define SQLITE_VERSION_NUMBER  3006001

 /*

 ** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>

 ** KEYWORDS: sqlite3_version

 **

 ** These features provide the same information as the [SQLITE_VERSION]

 ** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated

 ** with the library instead of the header file.  Cautious programmers might

 ** include a check in their application to verify that

 ** sqlite3_libversion_number() always returns the value

 ** [SQLITE_VERSION_NUMBER].

 **

 ** The sqlite3_libversion() function returns the same information as is

 ** in the sqlite3_version[] string constant.  The function is provided

 ** for use in DLLs since DLL users usually do not have direct access to string

 ** constants within the DLL.

 **

 ** INVARIANTS:

 **

 ** {H10021} The [sqlite3_libversion_number()] interface shall return

 **          an integer equal to [SQLITE_VERSION_NUMBER].

 **

 ** {H10022} The [sqlite3_version] string constant shall contain

 **          the text of the [SQLITE_VERSION] string.

 **

 ** {H10023} The [sqlite3_libversion()] function shall return

 **          a pointer to the [sqlite3_version] string constant.

 */

 SQLITE_EXTERN const char sqlite3_version[];

 const char *sqlite3_libversion(void);

 int sqlite3_libversion_number(void);

 /*

 ** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100>

 **

 ** SQLite can be compiled with or without mutexes.  When

 ** the [SQLITE_THREADSAFE] C preprocessor macro is true, mutexes

 ** are enabled and SQLite is threadsafe.  When that macro is false,

 ** 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 a program 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 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 this function shows

 ** only the default compile-time setting, not any run-time changes

 ** to that setting.

 **

 ** INVARIANTS:

 **

 ** {H10101} The [sqlite3_threadsafe()] function shall return nonzero if

 **          SQLite was compiled with the its mutexes enabled by default

 **          or zero if SQLite was compiled such that mutexes are

 **          permanently disabled.

 **

 ** {H10102} The value returned by the [sqlite3_threadsafe()] function

 **          shall not change when mutex setting are modified at

 **          runtime using the [sqlite3_config()] interface and 

 **          especially the [SQLITE_CONFIG_SINGLETHREAD],

 **          [SQLITE_CONFIG_MULTITHREAD], [SQLITE_CONFIG_SERIALIZED],

 **          and [SQLITE_CONFIG_MUTEX] verbs.

 */

 int sqlite3_threadsafe(void);

 /*

 ** CAPI3REF: Database Connection Handle {H12000} <S40200>

 ** 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 {H10200} <S10110>

 ** 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.

 **

 ** INVARIANTS:

 **

 ** {H10201} The [sqlite_int64] and [sqlite3_int64] type shall specify

 **          a 64-bit signed integer.

 **

 ** {H10202} The [sqlite_uint64] and [sqlite3_uint64] type shall specify

 **          a 64-bit unsigned integer.

 */

 #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 {H12010} <S30100><S40200>

 **

 ** This routine is the destructor for the [sqlite3] object.

 **

 ** Applications should [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.

 ** The [sqlite3_next_stmt()] interface can be used to locate all

 ** [prepared statements] associated with a [database connection] if desired.

 ** Typical code might look like this:

 **

 ** <blockquote><pre>

 ** sqlite3_stmt *pStmt;

 ** while( (pStmt = sqlite3_next_stmt(db, 0))!=0 ){

 **     sqlite3_finalize(pStmt);

 ** }

 ** </pre></blockquote>

 **

 ** If [sqlite3_close()] is invoked while a transaction is open,

 ** the transaction is automatically rolled back.

 **

 ** INVARIANTS:

 **

 ** {H12011} A successful call to [sqlite3_close(C)] shall destroy the

 **          [database connection] object C.

 **

 ** {H12012} A successful call to [sqlite3_close(C)] shall return SQLITE_OK.

 **

 ** {H12013} A successful call to [sqlite3_close(C)] shall release all

 **          memory and system resources associated with [database connection]

 **          C.

 **

 ** {H12014} A call to [sqlite3_close(C)] on a [database connection] C that

 **          has one or more open [prepared statements] shall fail with

 **          an [SQLITE_BUSY] error code.

 **

 ** {H12015} A call to [sqlite3_close(C)] where C is a NULL pointer shall

 **          return SQLITE_OK.

 **

 ** {H12019} When [sqlite3_close(C)] is invoked on a [database connection] C

 **          that has a pending transaction, the transaction shall be

 **          rolled back.

 **

 ** ASSUMPTIONS:

 **

 ** {A12016} 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.

 */

 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 {H12100} <S10000>

 **

 ** The sqlite3_exec() interface is a convenient way of running one or more

 ** SQL statements without having to write a lot of C code.  The UTF-8 encoded

 ** SQL statements are passed in as the second parameter to sqlite3_exec().

 ** The statements are evaluated one by one until either an error or

 ** an interrupt is encountered, or until they are all done.  The 3rd parameter

 ** is an optional callback that is invoked once for each row of any query

 ** results produced by the SQL statements.  The 5th parameter tells where

 ** to write any error messages.

 **

 ** The error message passed back through the 5th parameter is held

 ** in memory obtained from [sqlite3_malloc()].  To avoid a memory leak,

 ** the calling application should call [sqlite3_free()] on any error

 ** message returned through the 5th parameter when it has finished using

 ** the error message.

 **

 ** If the SQL statement in the 2nd parameter is NULL or an empty string

 ** or a string containing only whitespace and comments, then no SQL

 ** statements are evaluated and the database is not changed.

 **

 ** The sqlite3_exec() interface is implemented in terms of

 ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

 ** The sqlite3_exec() routine does nothing to the database that cannot be done

 ** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

 **

 ** INVARIANTS:

 **

 ** {H12101} A successful invocation of [sqlite3_exec(D,S,C,A,E)]

 **          shall sequentially evaluate all of the UTF-8 encoded,

 **          semicolon-separated SQL statements in the zero-terminated

 **          string S within the context of the [database connection] D.

 **

 ** {H12102} If the S parameter to [sqlite3_exec(D,S,C,A,E)] is NULL then

 **          the actions of the interface shall be the same as if the

 **          S parameter were an empty string.

 **

 ** {H12104} The return value of [sqlite3_exec()] shall be [SQLITE_OK] if all

 **          SQL statements run successfully and to completion.

 **

 ** {H12105} The return value of [sqlite3_exec()] shall be an appropriate

 **          non-zero [error code] if any SQL statement fails.

 **

 ** {H12107} If one or more of the SQL statements handed to [sqlite3_exec()]

 **          return results and the 3rd parameter is not NULL, then

 **          the callback function specified by the 3rd parameter shall be

 **          invoked once for each row of result.

 **

 ** {H12110} If the callback returns a non-zero value then [sqlite3_exec()]

 **          shall abort the SQL statement it is currently evaluating,

 **          skip all subsequent SQL statements, and return [SQLITE_ABORT].

 **

 ** {H12113} The [sqlite3_exec()] routine shall pass its 4th parameter through

 **          as the 1st parameter of the callback.

 **

 ** {H12116} The [sqlite3_exec()] routine shall set the 2nd parameter of its

 **          callback to be the number of columns in the current row of

 **          result.

 **

 ** {H12119} The [sqlite3_exec()] routine shall set the 3rd parameter of its

 **          callback to be an array of pointers to strings holding the

 **          values for each column in the current result set row as

 **          obtained from [sqlite3_column_text()].

 **

 ** {H12122} The [sqlite3_exec()] routine shall set the 4th parameter of its

 **          callback to be an array of pointers to strings holding the

 **          names of result columns as obtained from [sqlite3_column_name()].

 **

 ** {H12125} If the 3rd parameter to [sqlite3_exec()] is NULL then

 **          [sqlite3_exec()] shall silently discard query results.

 **

 ** {H12131} If an error occurs while parsing or evaluating any of the SQL

 **          statements in the S parameter of [sqlite3_exec(D,S,C,A,E)] and if

 **          the E parameter is not NULL, then [sqlite3_exec()] shall store

 **          in *E an appropriate error message written into memory obtained

 **          from [sqlite3_malloc()].

 **

 ** {H12134} The [sqlite3_exec(D,S,C,A,E)] routine shall set the value of

 **          *E to NULL if E is not NULL and there are no errors.

 **

 ** {H12137} The [sqlite3_exec(D,S,C,A,E)] function shall set the [error code]

 **          and message accessible via [sqlite3_errcode()],

 **          [sqlite3_errmsg()], and [sqlite3_errmsg16()].

 **

 ** {H12138} If the S parameter to [sqlite3_exec(D,S,C,A,E)] is NULL or an

 **          empty string or contains nothing other than whitespace, comments,

 **          and/or semicolons, then results of [sqlite3_errcode()],

 **          [sqlite3_errmsg()], and [sqlite3_errmsg16()]

 **          shall reset to indicate no errors.

 **

 ** ASSUMPTIONS:

 **

 ** {A12141} The first parameter to [sqlite3_exec()] must be an valid and open

 **          [database connection].

 **

 ** {A12142} The database connection must not be closed while

 **          [sqlite3_exec()] is running.

 **

 ** {A12143} The calling function should use [sqlite3_free()] to free

 **          the memory that *errmsg is left pointing at once the error

 **          message is no longer needed.

 **

 ** {A12145} The SQL statement text in the 2nd parameter to [sqlite3_exec()]

 **          must remain unchanged while [sqlite3_exec()] is running.

 */

 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 {H10210} <S10700>

 ** KEYWORDS: SQLITE_OK {error code} {error codes}

 ** KEYWORDS: {result code} {result codes}

 **

 ** Many SQLite functions return an integer result code from the set shown

 ** here in order to indicates success or failure.

 **

 ** New error codes may be added in future versions of SQLite.

 **

 ** See also: [SQLITE_IOERR_READ | extended result codes]

 */

 #define SQLITE_OK           0   /* Successful result */

 /* beginning-of-error-codes */

 #define SQLITE_ERROR        1   /* SQL error or missing database */

 #define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */

 #define SQLITE_PERM         3   /* Access permission denied */

 #define SQLITE_ABORT        4   /* Callback routine requested an abort */

 #define SQLITE_BUSY         5   /* The database file is locked */

 #define SQLITE_LOCKED       6   /* A table in the database is locked */

 #define SQLITE_NOMEM        7   /* A malloc() failed */

 #define SQLITE_READONLY     8   /* Attempt to write a readonly database */

 #define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/

 #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */

 #define SQLITE_CORRUPT     11   /* The database disk image is malformed */

 #define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */

 #define SQLITE_FULL        13   /* Insertion failed because database is full */

 #define SQLITE_CANTOPEN    14   /* Unable to open the database file */

 #define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */

 #define SQLITE_EMPTY       16   /* Database is empty */

 #define SQLITE_SCHEMA      17   /* The database schema changed */

 #define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */

 #define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */

 #define SQLITE_MISMATCH    20   /* Data type mismatch */

 #define SQLITE_MISUSE      21   /* Library used incorrectly */

 #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */

 #define SQLITE_AUTH        23   /* Authorization denied */

 #define SQLITE_FORMAT      24   /* Auxiliary database format error */

 #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */

 #define SQLITE_NOTADB      26   /* File opened that is not a database file */

 #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */

 #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */

 /* end-of-error-codes */

 /*

 ** CAPI3REF: Extended Result Codes {H10220} <S10700>

 ** 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.

 **

 ** INVARIANTS:

 **

 ** {H10223} The symbolic name for an extended result code shall contains

 **          a related primary result code as a prefix.

 **

 ** {H10224} Primary result code names shall contain a single "_" character.

 **

 ** {H10225} Extended result code names shall contain two or more "_" characters.

 **

 ** {H10226} The numeric value of an extended result code shall contain the

 **          numeric value of its corresponding primary result code in

 **          its least significant 8 bits.

 */

 #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))

 /*

 ** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>

 **

 ** 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

 #define SQLITE_OPEN_READWRITE        0x00000002

 #define SQLITE_OPEN_CREATE           0x00000004

 #define SQLITE_OPEN_DELETEONCLOSE    0x00000008

 #define SQLITE_OPEN_EXCLUSIVE        0x00000010

 #define SQLITE_OPEN_MAIN_DB          0x00000100

 #define SQLITE_OPEN_TEMP_DB          0x00000200

 #define SQLITE_OPEN_TRANSIENT_DB     0x00000400

 #define SQLITE_OPEN_MAIN_JOURNAL     0x00000800

 #define SQLITE_OPEN_TEMP_JOURNAL     0x00001000

 #define SQLITE_OPEN_SUBJOURNAL       0x00002000

 #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000

 #define SQLITE_OPEN_NOMUTEX          0x00008000

 /*

 ** CAPI3REF: Device Characteristics {H10240} <H11120>

 **

 ** The xDeviceCapabilities method of the [sqlite3_io_methods]

 ** object returns an integer which is a vector of the these

 ** bit values expressing I/O characteristics of the mass storage

 ** device that holds the file that the [sqlite3_io_methods]

 ** refers to.

 **

 ** The SQLITE_IOCAP_ATOMIC property means that all writes of

 ** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values

 ** mean that writes of blocks that are nnn bytes in size and

 ** are aligned to an address which is an integer multiple of

 ** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means

 ** that when data is appended to a file, the data is appended

 ** first then the size of the file is extended, never the other

 ** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that

 ** information is written to disk in the same order as calls

 ** to xWrite().

 */

 #define SQLITE_IOCAP_ATOMIC          0x00000001

 #define SQLITE_IOCAP_ATOMIC512       0x00000002

 #define SQLITE_IOCAP_ATOMIC1K        0x00000004

 #define SQLITE_IOCAP_ATOMIC2K        0x00000008

 #define SQLITE_IOCAP_ATOMIC4K        0x00000010

 #define SQLITE_IOCAP_ATOMIC8K        0x00000020

 #define SQLITE_IOCAP_ATOMIC16K       0x00000040

 #define SQLITE_IOCAP_ATOMIC32K       0x00000080

 #define SQLITE_IOCAP_ATOMIC64K       0x00000100

 #define SQLITE_IOCAP_SAFE_APPEND     0x00000200

 #define SQLITE_IOCAP_SEQUENTIAL      0x00000400

 /*

 ** CAPI3REF: File Locking Levels {H10250} <H11120> <H11310>

 **

 ** SQLite uses one of these integer values as the second

 ** argument to calls it makes to the xLock() and xUnlock() methods

 ** of an [sqlite3_io_methods] object.

 */

 #define SQLITE_LOCK_NONE          0

 #define SQLITE_LOCK_SHARED        1

 #define SQLITE_LOCK_RESERVED      2

 #define SQLITE_LOCK_PENDING       3

 #define SQLITE_LOCK_EXCLUSIVE     4

 /*

 ** CAPI3REF: Synchronization Type Flags {H10260} <H11120>

 **

 ** 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. The SQLITE_SYNC_NORMAL flag means

 ** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means

 ** to use Mac OS-X style fullsync instead of fsync().

 */

 #define SQLITE_SYNC_NORMAL        0x00002

 #define SQLITE_SYNC_FULL          0x00003

 #define SQLITE_SYNC_DATAONLY      0x00010

 /*

 ** CAPI3REF: OS Interface Open File Handle {H11110} <S20110>

 **

 ** An [sqlite3_file] object represents an open file in the OS

 ** interface layer.  Individual OS interface implementations will

 ** want to subclass this object by appending additional fields

 ** for their own use.  The pMethods entry is a pointer to an

 ** [sqlite3_io_methods] object that defines methods for performing

 ** I/O operations on the open file.

 */

 typedef struct sqlite3_file sqlite3_file;

 struct sqlite3_file {

   const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */

 };

 /*

 ** CAPI3REF: OS Interface File Virtual Methods Object {H11120} <S20110>

 **

 ** 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.

 **

 ** 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.

 **

 ** 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().

 */

 typedef struct sqlite3_io_methods sqlite3_io_methods;

 struct sqlite3_io_methods {

   int iVersion;

   int (*xClose)(sqlite3_file*);

   int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

   int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);

   int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);

   int (*xSync)(sqlite3_file*, int flags);

   int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);

   int (*xLock)(sqlite3_file*, int);

   int (*xUnlock)(sqlite3_file*, int);

   int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);

   int (*xFileControl)(sqlite3_file*, int op, void *pArg);

   int (*xSectorSize)(sqlite3_file*);

   int (*xDeviceCharacteristics)(sqlite3_file*);

   /* Additional methods may be added in future releases */

 };

 /*

 ** CAPI3REF: Standard File Control Opcodes {H11310} <S30800>

 **

 ** These integer constants are opcodes for the xFileControl method

 ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]

 ** interface.

 **

 ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This

 ** opcode causes the xFileControl method to write the current state of

 ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],

 ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])

 ** into an integer that the pArg argument points to. This capability

 ** is used during testing and only needs to be supported when SQLITE_TEST

 ** is defined.

 **

 */

 #define SQLITE_FCNTL_LOCKSTATE        1

 /*

 ** CAPI3REF: Mutex Handle {H17110} <S20130>

 **

 ** 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 {H11140} <S20100>

 **

 ** 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.

 **

 ** {H11141} SQLite will guarantee that the zFilename parameter to xOpen

 ** is either a NULL pointer or string obtained

 ** from xFullPathname().  SQLite further guarantees that

 ** the string will be valid and unchanged until xClose() is

 ** called. {END}  Because of the previous sentense,

 ** the [sqlite3_file] can safely store a pointer to the

 ** filename if it needs to remember the filename for some reason.

 ** If the zFilename parameter is xOpen is a NULL pointer then xOpen

 ** must invite 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].

 **

 ** {H11142} 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]. {END}

 ** If xOpen() opens a file read-only then it sets *pOutFlags to

 ** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.

 **

 ** {H11143} 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]

 ** </ul> {END}

 **

 ** The file I/O implementation can use the object type flags to

 ** change the way it deals with files.  For example, an application

 ** that does not care about crash recovery or rollback might make

 ** the open of a journal file a no-op.  Writes to this journal would

 ** also be no-ops, and any attempt to read the journal would return

 ** SQLITE_IOERR.  Or the implementation might recognize that a database

 ** file will be doing page-aligned sector reads and writes in a random

 ** order and set up its I/O subsystem accordingly.

 **

 ** SQLite might also add one of the following flags to the xOpen method:

 **

 ** <ul>

 ** <li> [SQLITE_OPEN_DELETEONCLOSE]

 ** <li> [SQLITE_OPEN_EXCLUSIVE]

 ** </ul>

 **

 ** {H11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be

 ** deleted when it is closed.  {H11146} The [SQLITE_OPEN_DELETEONCLOSE]

 ** will be set for TEMP  databases, journals and for subjournals.

 **

 ** {H11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened

 ** for exclusive access.  This flag is set for all files except

 ** for the main database file.

 **

 ** {H11148} At least szOsFile bytes of memory are allocated by SQLite

 ** to hold the  [sqlite3_file] structure passed as the third

 ** argument to xOpen. {END}  The xOpen method does not have to

 ** allocate the structure; it should just fill it in.

 **

 ** {H11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]

 ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to

 ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]

 ** to test whether a file is at least readable. {END}  The file can be a

 ** directory.

 **

 ** {H11150} SQLite will always allocate at least mxPathname+1 bytes for the

 ** output buffer xFullPathname. {H11151} The exact size of the output buffer

 ** is also passed as a parameter to both  methods. {END}  If the output buffer

 ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is

 ** handled as a fatal error by SQLite, vfs implementations should endeavor

 ** to prevent this by setting mxPathname to a sufficiently large value.

 **

 ** The xRandomness(), xSleep(), and xCurrentTime() interfaces

 ** are not strictly a part of the filesystem, but they are

 ** included in the VFS structure for completeness.

 ** The xRandomness() function attempts to return nBytes bytes

 ** of good-quality randomness into zOut.  The return value is

 ** the actual number of bytes of randomness obtained.

 ** The xSleep() method causes the calling thread to sleep for at

 ** least the number of microseconds given.  The xCurrentTime()

 ** method returns a Julian Day Number for the current date and time.

 */

 typedef struct sqlite3_vfs sqlite3_vfs;

 struct sqlite3_vfs {

   int iVersion;            /* Structure version number */

   int szOsFile;            /* Size of subclassed sqlite3_file */

   int mxPathname;          /* Maximum file pathname length */

   sqlite3_vfs *pNext;      /* Next registered VFS */

   const char *zName;       /* Name of this virtual file system */

   void *pAppData;          /* Pointer to application-specific data */

   int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,

                int flags, int *pOutFlags);

   int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);

   int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);

   int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);

   void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);

   void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);

   void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);

   void (*xDlClose)(sqlite3_vfs*, void*);

   int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);

   int (*xSleep)(sqlite3_vfs*, int microseconds);

   int (*xCurrentTime)(sqlite3_vfs*, double*);

   int (*xGetLastError)(sqlite3_vfs*, int, char *);

   /* New fields may be appended in figure versions.  The iVersion

   ** value will increment whenever this happens. */

 };

 /*

 ** CAPI3REF: Flags for the xAccess VFS method {H11190} <H11140>

 **

 ** {H11191} These integer constants can be used as the third parameter to

 ** the xAccess method of an [sqlite3_vfs] object. {END}  They determine

 ** what kind of permissions the xAccess method is looking for.

 ** {H11192} With SQLITE_ACCESS_EXISTS, the xAccess method

 ** simply checks whether the file exists.

 ** {H11193} With SQLITE_ACCESS_READWRITE, the xAccess method

 ** checks whether the file is both readable and writable.

 ** {H11194} With SQLITE_ACCESS_READ, the xAccess method

 ** checks whether the file is readable.

 */

 #define SQLITE_ACCESS_EXISTS    0

 #define SQLITE_ACCESS_READWRITE 1

 #define SQLITE_ACCESS_READ      2

 /*

 ** CAPI3REF: Initialize The SQLite Library {H10130} <S20000><S30100>

 **

 ** The sqlite3_initialize() routine initializes the

 ** SQLite library.  The sqlite3_shutdown() routine

 ** deallocates any resources that were allocated by sqlite3_initialize().

 **

 ** A call to sqlite3_initialize() is an "effective" call if it is

 ** the first time sqlite3_initialize() is invoked during the lifetime of

 ** the process, or if it is the first time sqlite3_initialize() is invoked

 ** following a call to sqlite3_shutdown().  Only an effective call

 ** of sqlite3_initialize() does any initialization.  All other calls

 ** are harmless no-ops.

 **

 ** Among other things, sqlite3_initialize() shall invoke

 ** sqlite3_os_init().  Similarly, sqlite3_shutdown()

 ** shall invoke sqlite3_os_end().

 **

 ** The sqlite3_initialize() routine returns SQLITE_OK on success.

 ** If for some reason, sqlite3_initialize() is unable to initialize

 ** the library (perhaps it is unable to allocate a needed resource such

 ** as a mutex) it returns an [error code] other than SQLITE_OK.

 **

 ** The sqlite3_initialize() routine is called internally by many other

 ** SQLite interfaces so that an application usually does not need to

 ** invoke sqlite3_initialize() directly.  For example, [sqlite3_open()]

 ** calls sqlite3_initialize() so the SQLite library will be automatically

 ** initialized when [sqlite3_open()] is called if it has not be initialized

 ** already.  However, if SQLite is compiled with the SQLITE_OMIT_AUTOINIT

 ** compile-time option, then the automatic calls to sqlite3_initialize()

 ** are omitted and the application must call sqlite3_initialize() directly

 ** prior to using any other SQLite interface.  For maximum portability,

 ** it is recommended that applications always invoke sqlite3_initialize()

 ** directly prior to using any other SQLite interface.  Future releases

 ** of SQLite may require this.  In other words, the behavior exhibited

 ** when SQLite is compiled with SQLITE_OMIT_AUTOINIT might become the

 ** default behavior in some future release of SQLite.

 **

 ** The sqlite3_os_init() routine does operating-system specific

 ** initialization of the SQLite library.  The sqlite3_os_end()

 ** routine undoes the effect of sqlite3_os_init().  Typical tasks

 ** performed by these routines include allocation or deallocation

 ** of static resources, initialization of global variables,

 ** setting up a default [sqlite3_vfs] module, or setting up

 ** a default configuration using [sqlite3_config()].

 **

 ** The application should never invoke either sqlite3_os_init()

 ** or sqlite3_os_end() directly.  The application should only invoke

 ** sqlite3_initialize() and sqlite3_shutdown().  The sqlite3_os_init()

 ** interface is called automatically by sqlite3_initialize() and

 ** sqlite3_os_end() is called by sqlite3_shutdown().  Appropriate

 ** implementations for sqlite3_os_init() and sqlite3_os_end()

 ** are built into SQLite when it is compiled for unix, windows, or os/2.

 ** When built for other platforms (using the SQLITE_OS_OTHER=1 compile-time

 ** option) the application must supply a suitable implementation for

 ** sqlite3_os_init() and sqlite3_os_end().  An application-supplied

 ** implementation of sqlite3_os_init() or sqlite3_os_end()

 ** must return SQLITE_OK on success and some other [error code] upon

 ** failure.

 */

 int sqlite3_initialize(void);

 int sqlite3_shutdown(void);

 int sqlite3_os_init(void);

 int sqlite3_os_end(void);

 /*

 ** CAPI3REF: Configuring The SQLite Library {H10145} <S20000><S30200>

 ** EXPERIMENTAL

 **

 ** The sqlite3_config() interface is used to make global configuration

 ** changes to SQLite in order to tune SQLite to the specific needs of

 ** the application.  The default configuration is recommended for most

 ** applications and so this routine is usually not necessary.  It is

 ** provided to support rare applications with unusual needs.

 **

 ** The sqlite3_config() interface is not threadsafe.  The application

 ** must insure that no other SQLite interfaces are invoked by other

 ** threads while sqlite3_config() is running.  Furthermore, sqlite3_config()

 ** may only be invoked prior to library initialization using

 ** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].

 ** Note, however, that sqlite3_config() can be called as part of the

 ** implementation of an application-defined [sqlite3_os_init()].

 **

 ** The first argument to sqlite3_config() is an integer

 ** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines

 ** what property of SQLite is to be configured.  Subsequent arguments

 ** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option]

 ** in the first argument.

 **

 ** When a configuration option is set, sqlite3_config() returns SQLITE_OK.

 ** If the option is unknown or SQLite is unable to set the option

 ** then this routine returns a non-zero [error code].

 */

 int sqlite3_config(int, ...);

 /*

 ** CAPI3REF: Configure database connections  {H10180} <S20000>

 ** EXPERIMENTAL

 **

 ** The sqlite3_db_config() interface is used to make configuration

 ** changes to a [database connection].  The interface is similar to

 ** [sqlite3_config()] except that the changes apply to a single

 ** [database connection] (specified in the first argument).  The

 ** sqlite3_db_config() interface can only be used immediately after

 ** the database connection is created using [sqlite3_open()],

 ** [sqlite3_open16()], or [sqlite3_open_v2()].  

 **

 ** The second argument to sqlite3_db_config(D,V,...)  is the

 ** configuration verb - an integer code that indicates what

 ** aspect of the [database connection] is being configured.

 ** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE].

 ** New verbs are likely to be added in future releases of SQLite.

 ** Additional arguments depend on the verb.

 */

 int sqlite3_db_config(sqlite3*, int op, ...);

 /*

 ** CAPI3REF: Memory Allocation Routines {H10155} <S20120>

 ** EXPERIMENTAL

 **

 ** An instance of this object defines the interface between SQLite

 ** and low-level memory allocation routines.

 **

 ** This object is used in only one place in the SQLite interface.

 ** A pointer to an instance of this object is the argument to

 ** [sqlite3_config()] when the configuration option is

 ** [SQLITE_CONFIG_MALLOC].  By creating an instance of this object

 ** and passing it to [sqlite3_config()] during configuration, an

 ** application can specify an alternative memory allocation subsystem

 ** for SQLite to use for all of its dynamic memory needs.

 **

 ** Note that SQLite comes with a built-in memory allocator that is

 ** perfectly adequate for the overwhelming majority of applications

 ** and that this object is only useful to a tiny minority of applications

 ** with specialized memory allocation requirements.  This object is

 ** also used during testing of SQLite in order to specify an alternative

 ** memory allocator that simulates memory out-of-memory conditions in

 ** order to verify that SQLite recovers gracefully from such

 ** conditions.

 **

 ** The xMalloc, xFree, and xRealloc methods must work like the

 ** malloc(), free(), and realloc() functions from the standard library.

 **

 ** xSize should return the allocated size of a memory allocation

 ** previously obtained from xMalloc or xRealloc.  The allocated size

 ** is always at least as big as the requested size but may be larger.

 **

 ** The xRoundup method returns what would be the allocated size of

 ** a memory allocation given a particular requested size.  Most memory

 ** allocators round up memory allocations at least to the next multiple

 ** of 8.  Some allocators round up to a larger multiple or to a power of 2.

 **

 ** The xInit method initializes the memory allocator.  (For example,

 ** it might allocate any require mutexes or initialize internal data

 ** structures.  The xShutdown method is invoked (indirectly) by

 ** [sqlite3_shutdown()] and should deallocate any resources acquired

 ** by xInit.  The pAppData pointer is used as the only parameter to

 ** xInit and xShutdown.

 */

 typedef struct sqlite3_mem_methods sqlite3_mem_methods;

 struct sqlite3_mem_methods {

   void *(*xMalloc)(int);         /* Memory allocation function */

   void (*xFree)(void*);          /* Free a prior allocation */

   void *(*xRealloc)(void*,int);  /* Resize an allocation */

   int (*xSize)(void*);           /* Return the size of an allocation */

   int (*xRoundup)(int);          /* Round up request size to allocation size */

   int (*xInit)(void*);           /* Initialize the memory allocator */

   void (*xShutdown)(void*);      /* Deinitialize the memory allocator */

   void *pAppData;                /* Argument to xInit() and xShutdown() */

 };

 /*

 ** CAPI3REF: Configuration Options {H10160} <S20000>

 ** EXPERIMENTAL

 **

 ** These constants are the available integer configuration options that

 ** can be passed as the first argument to the [sqlite3_config()] interface.

 **

 ** New configuration options may be added in future releases of SQLite.

 ** Existing configuration options might be discontinued.  Applications

 ** should check the return code from [sqlite3_config()] to make sure that

 ** the call worked.  The [sqlite3_config()] interface will return a

 ** non-zero [error code] if a discontinued or unsupported configuration option

 ** is invoked.

 **

 ** <dl>

 ** <dt>SQLITE_CONFIG_SINGLETHREAD</dt>

 ** <dd>There are no arguments to this option.  This option disables

 ** all mutexing and puts SQLite into a mode where it can only be used

 ** by a single thread.</dd>

 **

 ** <dt>SQLITE_CONFIG_MULTITHREAD</dt>

 ** <dd>There are no arguments to this option.  This option disables

 ** mutexing on [database connection] and [prepared statement] objects.

 ** The application is responsible for serializing access to

 ** [database connections] and [prepared statements].  But other mutexes

 ** are enabled so that SQLite will be safe to use in a multi-threaded

 ** environment.</dd>

 **

 ** <dt>SQLITE_CONFIG_SERIALIZED</dt>

 ** <dd>There are no arguments to this option.  This option enables

 ** all mutexes including the recursive

 ** mutexes on [database connection] and [prepared statement] objects.

 ** In this mode (which is the default when SQLite is compiled with

 ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access

 ** to [database connections] and [prepared statements] so that the

 ** application is free to use the same [database connection] or the

 ** same [prepared statement] in different threads at the same time.

 **

 ** <p>This configuration option merely sets the default mutex 

 ** behavior to serialize access to [database connections].  Individual

 ** [database connections] can override this setting

 ** using the [SQLITE_OPEN_NOMUTEX] flag to [sqlite3_open_v2()].</p></dd>

 **

 ** <dt>SQLITE_CONFIG_MALLOC</dt>

 ** <dd>This option takes a single argument which is a pointer to an

 ** instance of the [sqlite3_mem_methods] structure.  The argument specifies

 ** alternative low-level memory allocation routines to be used in place of

 ** the memory allocation routines built into SQLite.</dd>

 **

 ** <dt>SQLITE_CONFIG_GETMALLOC</dt>

 ** <dd>This option takes a single argument which is a pointer to an

 ** instance of the [sqlite3_mem_methods] structure.  The [sqlite3_mem_methods]

 ** structure is filled with the currently defined memory allocation routines.

 ** This option can be used to overload the default memory allocation

 ** routines with a wrapper that simulations memory allocation failure or

 ** tracks memory usage, for example.</dd>

 **

 ** <dt>SQLITE_CONFIG_MEMSTATUS</dt>

 ** <dd>This option takes single argument of type int, interpreted as a 

 ** boolean, which enables or disables the collection of memory allocation 

 ** statistics. When disabled, the following SQLite interfaces become 

 ** non-operational:

 **   <ul>

 **   <li> [sqlite3_memory_used()]

 **   <li> [sqlite3_memory_highwater()]

 **   <li> [sqlite3_soft_heap_limit()]

 **   <li> [sqlite3_status()]

 **   </ul>

 ** </dd>

 **

 ** <dt>SQLITE_CONFIG_SCRATCH</dt>

 ** <dd>This option specifies a static memory buffer that SQLite can use for

 ** scratch memory.  There are three arguments:  A pointer to the memory, the

 ** size of each scratch buffer (sz), and the number of buffers (N).  The sz

 ** argument must be a multiple of 16. The sz parameter should be a few bytes

 ** larger than the actual scratch space required due internal overhead.

 ** The first

 ** argument should point to an allocation of at least sz*N bytes of memory.

 ** SQLite will use no more than one scratch buffer at once per thread, so

 ** N should be set to the expected maximum number of threads.  The sz

 ** parameter should be 6 times the size of the largest database page size.

 ** Scratch buffers are used as part of the btree balance operation.  If

 ** The btree balancer needs additional memory beyond what is provided by

 ** scratch buffers or if no scratch buffer space is specified, then SQLite

 ** goes to [sqlite3_malloc()] to obtain the memory it needs.</dd>

 **

 ** <dt>SQLITE_CONFIG_PAGECACHE</dt>

 ** <dd>This option specifies a static memory buffer that SQLite can use for

 ** the database page cache.  There are three arguments: A pointer to the

 ** memory, the size of each page buffer (sz), and the number of pages (N).

 ** The sz argument must be a power of two between 512 and 32768.  The first

 ** argument should point to an allocation of at least sz*N bytes of memory.

 ** SQLite will use the memory provided by the first argument to satisfy its

 ** memory needs for the first N pages that it adds to cache.  If additional

 ** page cache memory is needed beyond what is provided by this option, then

 ** SQLite goes to [sqlite3_malloc()] for the additional storage space.

 ** The implementation might use one or more of the N buffers to hold 

 ** memory accounting information. </dd>

 **

 ** <dt>SQLITE_CONFIG_HEAP</dt>

 ** <dd>This option specifies a static memory buffer that SQLite will use

 ** for all of its dynamic memory allocation needs beyond those provided

 ** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].

 ** There are three arguments: A pointer to the memory, the number of

 ** bytes in the memory buffer, and the minimum allocation size.  If

 ** the first pointer (the memory pointer) is NULL, then SQLite reverts

 ** to using its default memory allocator (the system malloc() implementation),

 ** undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  If the

 ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or

 ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory

 ** allocator is engaged to handle all of SQLites memory allocation needs.</dd>

 **

 ** <dt>SQLITE_CONFIG_MUTEX</dt>

 ** <dd>This option takes a single argument which is a pointer to an

 ** instance of the [sqlite3_mutex_methods] structure.  The argument specifies

 ** alternative low-level mutex routines to be used in place

 ** the mutex routines built into SQLite.</dd>

 **

 ** <dt>SQLITE_CONFIG_GETMUTEX</dt>

 ** <dd>This option takes a single argument which is a pointer to an

 ** instance of the [sqlite3_mutex_methods] structure.  The

 ** [sqlite3_mutex_methods]

 ** structure is filled with the currently defined mutex routines.

 ** This option can be used to overload the default mutex allocation

 ** routines with a wrapper used to track mutex usage for performance

 ** profiling or testing, for example.</dd>

 **

 ** <dt>SQLITE_CONFIG_LOOKASIDE</dt>

 ** <dd>This option takes two arguments that determine the default

 ** memory allcation lookaside optimization.  The first argument is the

 ** size of each lookaside buffer slot and the second is the number of

 ** slots allocated to each database connection.</dd>

 **

 ** </dl>

 */

 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */

 #define SQLITE_CONFIG_MULTITHREAD   2  /* nil */

 #define SQLITE_CONFIG_SERIALIZED    3  /* nil */

 #define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */

 #define SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */

 #define SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */

 #define SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */

 #define SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */

 #define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */

 #define SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */

 #define SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */

 #define SQLITE_CONFIG_CHUNKALLOC   12  /* int threshold */

 #define SQLITE_CONFIG_LOOKASIDE    13  /* int int */

 /*

 ** CAPI3REF: Configuration Options {H10170} <S20000>

 ** EXPERIMENTAL

 **

 ** These constants are the available integer configuration options that

 ** can be passed as the second argument to the [sqlite3_db_config()] interface.

 **

 ** New configuration options may be added in future releases of SQLite.

 ** Existing configuration options might be discontinued.  Applications

 ** should check the return code from [sqlite3_db_config()] to make sure that

 ** the call worked.  The [sqlite3_db_config()] interface will return a

 ** non-zero [error code] if a discontinued or unsupported configuration option

 ** is invoked.

 **

 ** <dl>

 ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>

 ** <dd>This option takes three additional arguments that determine the 

 ** [lookaside memory allocator] configuration for the [database connection].

 ** The first argument (the third parameter to [sqlite3_db_config()] is a

 ** pointer to a memory buffer to use for lookaside memory.  The first

 ** argument may be NULL in which case SQLite will allocate the lookaside

 ** buffer itself using [sqlite3_malloc()].  The second argument is the

 ** size of each lookaside buffer slot and the third argument is the number of

 ** slots.  The size of the buffer in the first argument must be greater than

 ** or equal to the product of the second and third arguments.</dd>

 **

 ** </dl>

 */

 #define SQLITE_DBCONFIG_LOOKASIDE    1001  /* void* int int */

 /*

 ** CAPI3REF: Enable Or Disable Extended Result Codes {H12200} <S10700>

 **

 ** The sqlite3_extended_result_codes() routine enables or disables the

 ** [extended result codes] feature of SQLite. The extended result

 ** codes are disabled by default for historical compatibility considerations.

 **

 ** INVARIANTS:

 **

 ** {H12201} Each new [database connection] shall have the

 **          [extended result codes] feature disabled by default.

 **

 ** {H12202} The [sqlite3_extended_result_codes(D,F)] interface shall enable

 **          [extended result codes] for the  [database connection] D

 **          if the F parameter is true, or disable them if F is false.

 */

 int sqlite3_extended_result_codes(sqlite3*, int onoff);

 /*

 ** CAPI3REF: Last Insert Rowid {H12220} <S10700>

 **

 ** Each entry in an SQLite table has a unique 64-bit signed

 ** integer key called the "rowid". The rowid is always available

 ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those

 ** names are not also used by explicitly declared columns. If

 ** the table has a column of type INTEGER PRIMARY KEY then that column

 ** is another alias for the rowid.

 **

 ** This routine returns the rowid of the most recent

 ** successful INSERT into the database from the [database connection]

 ** in the first argument.  If no successful INSERTs

 ** have ever occurred on that database connection, zero is returned.

 **

 ** If an INSERT occurs within a trigger, then the rowid of the inserted

 ** row is returned by this routine as long as the trigger is running.

 ** But once the trigger terminates, the value returned by this routine

 ** reverts to the last value inserted before the trigger fired.

 **

 ** An INSERT that fails due to a constraint violation is not a

 ** successful INSERT and does not change the value returned by this

 ** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,

 ** and INSERT OR ABORT make no changes to the return value of this

 ** routine when their insertion fails.  When INSERT OR REPLACE

 ** encounters a constraint violation, it does not fail.  The

 ** INSERT continues to completion after deleting rows that caused

 ** the constraint problem so INSERT OR REPLACE will always change

 ** the return value of this interface.

 **

 ** For the purposes of this routine, an INSERT is considered to

 ** be successful even if it is subsequently rolled back.

 **

 ** INVARIANTS:

 **

 ** {H12221} The [sqlite3_last_insert_rowid()] function returns the rowid

 **          of the most recent successful INSERT performed on the same

 **          [database connection] and within the same or higher level

 **          trigger context, or zero if there have been no qualifying inserts.

 **

 ** {H12223} The [sqlite3_last_insert_rowid()] function returns the

 **          same value when called from the same trigger context

 **          immediately before and after a ROLLBACK.

 **

 ** ASSUMPTIONS:

 **

 ** {A12232} If a separate thread performs a new INSERT on the same

 **          database connection while the [sqlite3_last_insert_rowid()]

 **          function is running and thus changes the last insert rowid,

 **          then the value returned by [sqlite3_last_insert_rowid()] is

 **          unpredictable and might not equal either the old or the new

 **          last insert rowid.

 */

 sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);

 /*

 ** CAPI3REF: Count The Number Of Rows Modified {H12240} <S10600>

 **

 ** This function returns the number of database rows that were changed

 ** or inserted or deleted by the most recently completed SQL statement

 ** on the [database connection] specified by the first parameter.

 ** Only changes that are directly specified by the INSERT, UPDATE,

 ** or DELETE statement are counted.  Auxiliary changes caused by

 ** triggers are not counted. Use the [sqlite3_total_changes()] function

 ** to find the total number of changes including changes caused by triggers.

 **

 ** A "row change" is a change to a single row of a single table

 ** caused by an INSERT, DELETE, or UPDATE statement.  Rows that

 ** are changed as side effects of REPLACE constraint resolution,

 ** rollback, ABORT processing, DROP TABLE, or by any other

 ** mechanisms do not count as direct row changes.

 **

 ** A "trigger context" is a scope of execution that begins and

 ** ends with the script of a trigger.  Most SQL statements are

 ** evaluated outside of any trigger.  This is the "top level"

 ** trigger context.  If a trigger fires from the top level, a

 ** new trigger context is entered for the duration of that one

 ** trigger.  Subtriggers create subcontexts for their duration.

 **

 ** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does

 ** not create a new trigger context.

 **

 ** This function returns the number of direct row changes in the

 ** most recent INSERT, UPDATE, or DELETE statement within the same

 ** trigger context.

 **

 ** Thus, when called from the top level, this function returns the

 ** number of changes in the most recent INSERT, UPDATE, or DELETE

 ** that also occurred at the top level.  Within the body of a trigger,

 ** the sqlite3_changes() interface can be called to find the number of

 ** changes in the most recently completed INSERT, UPDATE, or DELETE

 ** statement within the body of the same trigger.

 ** However, the number returned does not include changes

 ** caused by subtriggers since those have their own context.

 **

 ** SQLite implements the command "DELETE FROM table" without a WHERE clause

 ** by dropping and recreating the table.  (This is much faster than going

 ** through and deleting individual elements from the table.)  Because of this

 ** optimization, the deletions in "DELETE FROM table" are not row changes and

 ** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()]

 ** functions, regardless of the number of elements that were originally

 ** in the table.  To get an accurate count of the number of rows deleted, use

 ** "DELETE FROM table WHERE 1" instead.

 **

 ** INVARIANTS:

 **

 ** {H12241} The [sqlite3_changes()] function shall return the number of

 **          row changes caused by the most recent INSERT, UPDATE,

 **          or DELETE statement on the same database connection and

 **          within the same or higher trigger context, or zero if there have

 **          not been any qualifying row changes.

 **

 ** {H12243} Statements of the form "DELETE FROM tablename" with no

 **          WHERE clause shall cause subsequent calls to

 **          [sqlite3_changes()] to return zero, regardless of the

 **          number of rows originally in the table.

 **

 ** ASSUMPTIONS:

 **

 ** {A12252} If a separate thread makes changes on the same database connection

 **          while [sqlite3_changes()] is running then the value returned

 **          is unpredictable and not meaningful.

 */

 int sqlite3_changes(sqlite3*);

 /*

 ** CAPI3REF: Total Number Of Rows Modified {H12260} <S10600>

 **

 ** This function returns the number of row changes caused by INSERT,

 ** UPDATE or DELETE statements since the [database connection] was opened.

 ** The count includes all changes from all trigger contexts.  However,

 ** the count does not include changes used to implement REPLACE constraints,

 ** do rollbacks or ABORT processing, or DROP table processing.

 ** The changes are counted as soon as the statement that makes them is

 ** completed (when the statement handle is passed to [sqlite3_reset()] or

 ** [sqlite3_finalize()]).

 **

 ** SQLite implements the command "DELETE FROM table" without a WHERE clause

 ** by dropping and recreating the table.  (This is much faster than going

 ** through and deleting individual elements from the table.)  Because of this

 ** optimization, the deletions in "DELETE FROM table" are not row changes and

 ** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()]

 ** functions, regardless of the number of elements that were originally

 ** in the table.  To get an accurate count of the number of rows deleted, use

 ** "DELETE FROM table WHERE 1" instead.

 **

 ** See also the [sqlite3_changes()] interface.

 **

 ** INVARIANTS:

 **

 ** {H12261} The [sqlite3_total_changes()] returns the total number

 **          of row changes caused by INSERT, UPDATE, and/or DELETE

 **          statements on the same [database connection], in any

 **          trigger context, since the database connection was created.

 **

 ** {H12263} Statements of the form "DELETE FROM tablename" with no

 **          WHERE clause shall not change the value returned

 **          by [sqlite3_total_changes()].

 **

 ** ASSUMPTIONS:

 **

 ** {A12264} If a separate thread makes changes on the same database connection

 **          while [sqlite3_total_changes()] is running then the value

 **          returned is unpredictable and not meaningful.

 */

 int sqlite3_total_changes(sqlite3*);

 /*

 ** CAPI3REF: Interrupt A Long-Running Query {H12270} <S30500>

 **

 ** This function causes any pending database operation to abort and

 ** return at its earliest opportunity. This routine is typically

 ** called in response to a user action such as pressing "Cancel"

 ** or Ctrl-C where the user wants a long query operation to halt

 ** immediately.

 **

 ** It is safe to call this routine from a thread different from the

 ** thread that is currently running the database operation.  But it

 ** is not safe to call this routine with a [database connection] that

 ** is closed or might close before sqlite3_interrupt() returns.

 **

 ** If an SQL operation is very nearly finished at the time when

 ** sqlite3_interrupt() is called, then it might not have an opportunity

 ** to be interrupted and might continue to completion.

 **

 ** An SQL operation that is interrupted will return [SQLITE_INTERRUPT].

 ** If the interrupted SQL operation is an INSERT, UPDATE, or DELETE

 ** that is inside an explicit transaction, then the entire transaction

 ** will be rolled back automatically.

 **

 ** A call to sqlite3_interrupt() has no effect on SQL statements

 ** that are started after sqlite3_interrupt() returns.

 **

 ** INVARIANTS:

 **

 ** {H12271} The [sqlite3_interrupt()] interface will force all running

 **          SQL statements associated with the same database connection

 **          to halt after processing at most one additional row of data.

 **

 ** {H12272} Any SQL statement that is interrupted by [sqlite3_interrupt()]

 **          will return [SQLITE_INTERRUPT].

 **

 ** ASSUMPTIONS:

 **

 ** {A12279} If the database connection closes while [sqlite3_interrupt()]

 **          is running then bad things will likely happen.

 */

 void sqlite3_interrupt(sqlite3*);

 /*

 ** CAPI3REF: Determine If An SQL Statement Is Complete {H10510} <S70200>

 **

 ** These routines are useful for command-line input to determine if the

 ** currently entered text seems to form complete a SQL statement or

 ** if additional input is needed before sending the text into

 ** SQLite for parsing.  These routines return true if the input string

 ** appears to be a complete SQL statement.  A statement is judged to be

 ** complete if it ends with a semicolon token and is not a fragment of a

 ** CREATE TRIGGER statement.  Semicolons that are embedded within

 ** string literals or quoted identifier names or comments are not

 ** independent tokens (they are part of the token in which they are

 ** embedded) and thus do not count as a statement terminator.

 **

 ** These routines do not parse the SQL statements thus

 ** will not detect syntactically incorrect SQL.

 **

 ** INVARIANTS:

 **

 ** {H10511} A successful evaluation of [sqlite3_complete()] or

 **          [sqlite3_complete16()] functions shall

 **          return a numeric 1 if and only if the last non-whitespace

 **          token in their input is a semicolon that is not in between

 **          the BEGIN and END of a CREATE TRIGGER statement.

 **

 ** {H10512} If a memory allocation error occurs during an invocation

 **          of [sqlite3_complete()] or [sqlite3_complete16()] then the

 **          routine shall return [SQLITE_NOMEM].

 **

 ** ASSUMPTIONS:

 **

 ** {A10512} The input to [sqlite3_complete()] must be a zero-terminated

 **          UTF-8 string.

 **

 ** {A10513} The input to [sqlite3_complete16()] must be a zero-terminated

 **          UTF-16 string in native byte order.

 */

 int sqlite3_complete(const char *sql);

 int sqlite3_complete16(const void *sql);

 /*

 ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {H12310} <S40400>

 **

 ** This routine sets a callback function that might be invoked whenever

 ** an attempt is made to open a database table that another thread

 ** or process has locked.

 **

 ** If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]

 ** is returned immediately upon encountering the lock. If the busy callback

 ** is not NULL, then the callback will be invoked with two arguments.

 **

 ** The first argument to the handler is a copy of the void* pointer which

 ** is the third argument to sqlite3_busy_handler().  The second argument to

 ** the handler callback is the number of times that the busy handler has

 ** been invoked for this locking event.  If the

 ** busy callback returns 0, then no additional attempts are made to

 ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.

 ** If the callback returns non-zero, then another attempt

 ** is made to open the database for reading and the cycle repeats.

 **

 ** The presence of a busy handler does not guarantee that it will be invoked

 ** when there is lock contention. If SQLite determines that invoking the busy

 ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]

 ** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler.

 ** Consider a scenario where one process is holding a read lock that

 ** it is trying to promote to a reserved lock and

 ** a second process is holding a reserved lock that it is trying

 ** to promote to an exclusive lock.  The first process cannot proceed

 ** because it is blocked by the second and the second process cannot

 ** proceed because it is blocked by the first.  If both processes

 ** invoke the busy handlers, neither will make any progress.  Therefore,

 ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this

 ** will induce the first process to release its read lock and allow

 ** the second process to proceed.

 **

 ** The default busy callback is NULL.

 **

 ** The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]

 ** when SQLite is in the middle of a large transaction where all the

 ** changes will not fit into the in-memory cache.  SQLite will

 ** already hold a RESERVED lock on the database file, but it needs

 ** to promote this lock to EXCLUSIVE so that it can spill cache

 ** pages into the database file without harm to concurrent

 ** readers.  If it is unable to promote the lock, then the in-memory

 ** cache will be left in an inconsistent state and so the error

 ** code is promoted from the relatively benign [SQLITE_BUSY] to

 ** the more severe [SQLITE_IOERR_BLOCKED].  This error code promotion

 ** forces an automatic rollback of the changes.  See the

 ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError">

 ** CorruptionFollowingBusyError</a> wiki page for a discussion of why

 ** this is important.

 **

 ** There can only be a single busy handler defined for each

 ** [database connection].  Setting a new busy handler clears any

 ** previously set handler.  Note that calling [sqlite3_busy_timeout()]

 ** will also set or clear the busy handler.

 **

 ** INVARIANTS:

 **

 ** {H12311} The [sqlite3_busy_handler(D,C,A)] function shall replace

 **          busy callback in the [database connection] D with a new

 **          a new busy handler C and application data pointer A.

 **

 ** {H12312} Newly created [database connections] shall have a busy

 **          handler of NULL.

 **

 ** {H12314} When two or more [database connections] share a

 **          [sqlite3_enable_shared_cache | common cache],

 **          the busy handler for the database connection currently using

 **          the cache shall be invoked when the cache encounters a lock.

 **

 ** {H12316} If a busy handler callback returns zero, then the SQLite interface

 **          that provoked the locking event shall return [SQLITE_BUSY].

 **

 ** {H12318} SQLite shall invokes the busy handler with two arguments which

 **          are a copy of the pointer supplied by the 3rd parameter to

 **          [sqlite3_busy_handler()] and a count of the number of prior

 **          invocations of the busy handler for the same locking event.

 **

 ** ASSUMPTIONS:

 **

 ** {A12319} A busy handler must not close the database connection

 **          or [prepared statement] that invoked the busy handler.

 */

 int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);

 /*

 ** CAPI3REF: Set A Busy Timeout {H12340} <S40410>

 **

 ** This routine sets a [sqlite3_busy_handler | busy handler] that sleeps

 ** for a specified amount of time when a table is locked.  The handler

 ** will sleep multiple times until at least "ms" milliseconds of sleeping

 ** have accumulated. {H12343} After "ms" milliseconds of sleeping,

 ** the handler returns 0 which causes [sqlite3_step()] to return

 ** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].

 **

 ** Calling this routine with an argument less than or equal to zero

 ** turns off all busy handlers.

 **

 ** There can only be a single busy handler for a particular

 ** [database connection] any any given moment.  If another busy handler

 ** was defined  (using [sqlite3_busy_handler()]) prior to calling

 ** this routine, that other busy handler is cleared.

 **

 ** INVARIANTS:

 **

 ** {H12341} The [sqlite3_busy_timeout()] function shall override any prior

 **          [sqlite3_busy_timeout()] or [sqlite3_busy_handler()] setting

 **          on the same [database connection].

 **

 ** {H12343} If the 2nd parameter to [sqlite3_busy_timeout()] is less than

 **          or equal to zero, then the busy handler shall be cleared so that

 **          all subsequent locking events immediately return [SQLITE_BUSY].

 **

 ** {H12344} If the 2nd parameter to [sqlite3_busy_timeout()] is a positive

 **          number N, then a busy handler shall be set that repeatedly calls

 **          the xSleep() method in the [sqlite3_vfs | VFS interface] until

 **          either the lock clears or until the cumulative sleep time

 **          reported back by xSleep() exceeds N milliseconds.

 */

 int sqlite3_busy_timeout(sqlite3*, int ms);

 /*

 ** CAPI3REF: Convenience Routines For Running Queries {H12370} <S10000>

 **

 ** Definition: A <b>result table</b> is memory data structure created by the

 ** [sqlite3_get_table()] interface.  A result table records the

 ** complete query results from one or more queries.

 **

 ** The table conceptually has a number of rows and columns.  But

 ** these numbers are not part of the result table itself.  These

 ** numbers are obtained separately.  Let N be the number of rows

 ** and M be the number of columns.

 **

 ** A result table is an array of pointers to zero-terminated UTF-8 strings.

 ** There are (N+1)*M elements in the array.  The first M pointers point

 ** to zero-terminated strings that  contain the names of the columns.

 ** The remaining entries all point to query results.  NULL values result

 ** in NULL pointers.  All other values are in their UTF-8 zero-terminated

 ** string representation as returned by [sqlite3_column_text()].

 **

 ** A result table might consist of one or more memory allocations.

 ** It is not safe to pass a result table directly to [sqlite3_free()].

 ** A result table should be deallocated using [sqlite3_free_table()].

 **

 ** As an example of the result table format, suppose a query result

 ** is as follows:

 **

 ** <blockquote><pre>

 **        Name        | Age

 **        -----------------------

 **        Alice       | 43

 **        Bob         | 28

 **        Cindy       | 21

 ** </pre></blockquote>

 **

 ** There are two column (M==2) and three rows (N==3).  Thus the

 ** result table has 8 entries.  Suppose the result table is stored

 ** in an array names azResult.  Then azResult holds this content:

 **

 ** <blockquote><pre>

 **        azResult[0] = "Name";

 **        azResult[1] = "Age";

 **        azResult[2] = "Alice";

 **        azResult[3] = "43";

 **        azResult[4] = "Bob";

 **        azResult[5] = "28";

 **        azResult[6] = "Cindy";

 **        azResult[7] = "21";

 ** </pre></blockquote>

 **

 ** The sqlite3_get_table() function evaluates one or more

 ** semicolon-separated SQL statements in the zero-terminated UTF-8

 ** string of its 2nd parameter.  It returns a result table to the

 ** pointer given in its 3rd parameter.

 **

 ** After the calling function has finished using the result, it should

 ** pass the pointer to the result table to sqlite3_free_table() in order to

 ** release the memory that was malloced.  Because of the way the

 ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling

 ** function must not try to call [sqlite3_free()] directly.  Only

 ** [sqlite3_free_table()] is able to release the memory properly and safely.

 **

 ** The sqlite3_get_table() interface is implemented as a wrapper around

 ** [sqlite3_exec()].  The sqlite3_get_table() routine does not have access

 ** to any internal data structures of SQLite.  It uses only the public

 ** interface defined here.  As a consequence, errors that occur in the

 ** wrapper layer outside of the internal [sqlite3_exec()] call are not

 ** reflected in subsequent calls to [sqlite3_errcode()] or [sqlite3_errmsg()].

 **

 ** INVARIANTS:

 **

 ** {H12371} If a [sqlite3_get_table()] fails a memory allocation, then

 **          it shall free the result table under construction, abort the

 **          query in process, skip any subsequent queries, set the

 **          *pazResult output pointer to NULL and return [SQLITE_NOMEM].

 **

 ** {H12373} If the pnColumn parameter to [sqlite3_get_table()] is not NULL

 **          then a successful invocation of [sqlite3_get_table()] shall

 **          write the number of columns in the

 **          result set of the query into *pnColumn.

 **

 ** {H12374} If the pnRow parameter to [sqlite3_get_table()] is not NULL

 **          then a successful invocation of [sqlite3_get_table()] shall

 **          writes the number of rows in the

 **          result set of the query into *pnRow.

 **

 ** {H12376} A successful invocation of [sqlite3_get_table()] that computes

 **          N rows of result with C columns per row shall make *pazResult

 **          point to an array of pointers to (N+1)*C strings where the first

 **          C strings are column names as obtained from

 **          [sqlite3_column_name()] and the rest are column result values

 **          obtained from [sqlite3_column_text()].

 **

 ** {H12379} The values in the pazResult array returned by [sqlite3_get_table()]

 **          shall remain valid until cleared by [sqlite3_free_table()].

 **

 ** {H12382} When an error occurs during evaluation of [sqlite3_get_table()]

 **          the function shall set *pazResult to NULL, write an error message

 **          into memory obtained from [sqlite3_malloc()], make

 **          **pzErrmsg point to that error message, and return a

 **          appropriate [error code].

 */

 int sqlite3_get_table(

   sqlite3 *db,          /* An open database */

   const char *zSql,     /* SQL to be evaluated */

   char ***pazResult,    /* Results of the query */

   int *pnRow,           /* Number of result rows written here */

   int *pnColumn,        /* Number of result columns written here */

   char **pzErrmsg       /* Error msg written here */

 );

 void sqlite3_free_table(char **result);

 /*

 ** CAPI3REF: Formatted String Printing Functions {H17400} <S70000><S20000>

 **

 ** These routines are workalikes of the "printf()" family of functions

 ** from the standard C library.

 **

 ** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their

 ** results into memory obtained from [sqlite3_malloc()].

 ** The strings returned by these two routines should be

 ** released by [sqlite3_free()].  Both routines return a

 ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough

 ** memory to hold the resulting string.

 **

 ** In sqlite3_snprintf() routine is similar to "snprintf()" from

 ** the standard C library.  The result is written into the

 ** buffer supplied as the second parameter whose size is given by

 ** the first parameter. Note that the order of the

 ** first two parameters is reversed from snprintf().  This is an

 ** historical accident that cannot be fixed without breaking

 ** backwards compatibility.  Note also that sqlite3_snprintf()

 ** returns a pointer to its buffer instead of the number of

 ** characters actually written into the buffer.  We admit that

 ** the number of characters written would be a more useful return

 ** value but we cannot change the implementation of sqlite3_snprintf()

 ** now without breaking compatibility.

 **

 ** As long as the buffer size is greater than zero, sqlite3_snprintf()

 ** guarantees that the buffer is always zero-terminated.  The first

 ** parameter "n" is the total size of the buffer, including space for

 ** the zero terminator.  So the longest string that can be completely

 ** written will be n-1 characters.

 **

 ** These routines all implement some additional formatting

 ** options that are useful for constructing SQL statements.

 ** All of the usual printf() formatting options apply.  In addition, there

 ** is are "%q", "%Q", and "%z" options.

 **

 ** The %q option works like %s in that it substitutes a null-terminated

 ** string from the argument list.  But %q also doubles every '\'' character.

 ** %q is designed for use inside a string literal.  By doubling each '\''

 ** character it escapes that character and allows it to be inserted into

 ** the string.

 **

 ** For example, assume the string variable zText contains text as follows:

 **

 ** <blockquote><pre>

 **  char *zText = "It's a happy day!";

 ** </pre></blockquote>

 **

 ** One can use this text in an SQL statement as follows:

 **

 ** <blockquote><pre>

 **  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);

 **  sqlite3_exec(db, zSQL, 0, 0, 0);

 **  sqlite3_free(zSQL);

 ** </pre></blockquote>

 **

 ** Because the %q format string is used, the '\'' character in zText

 ** is escaped and the SQL generated is as follows:

 **

 ** <blockquote><pre>

 **  INSERT INTO table1 VALUES('It''s a happy day!')

 ** </pre></blockquote>

 **

 ** This is correct.  Had we used %s instead of %q, the generated SQL

 ** would have looked like this:

 **

 ** <blockquote><pre>

 **  INSERT INTO table1 VALUES('It's a happy day!');

 ** </pre></blockquote>

 **

 ** This second example is an SQL syntax error.  As a general rule you should

 ** always use %q instead of %s when inserting text into a string literal.

 **

 ** The %Q option works like %q except it also adds single quotes around

 ** the outside of the total string.  Additionally, if the parameter in the

 ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without

 ** single quotes) in place of the %Q option.  So, for example, one could say:

 **

 ** <blockquote><pre>

 **  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);

 **  sqlite3_exec(db, zSQL, 0, 0, 0);

 **  sqlite3_free(zSQL);

 ** </pre></blockquote>

 **

 ** The code above will render a correct SQL statement in the zSQL

 ** variable even if the zText variable is a NULL pointer.

 **

 ** The "%z" formatting option works exactly like "%s" with the

 ** addition that after the string has been read and copied into

 ** the result, [sqlite3_free()] is called on the input string. {END}

 **

 ** INVARIANTS:

 **

 ** {H17403}  The [sqlite3_mprintf()] and [sqlite3_vmprintf()] interfaces

 **           return either pointers to zero-terminated UTF-8 strings held in

 **           memory obtained from [sqlite3_malloc()] or NULL pointers if

 **           a call to [sqlite3_malloc()] fails.

 **

 ** {H17406}  The [sqlite3_snprintf()] interface writes a zero-terminated

 **           UTF-8 string into the buffer pointed to by the second parameter

 **           provided that the first parameter is greater than zero.

 **

 ** {H17407}  The [sqlite3_snprintf()] interface does not write slots of

 **           its output buffer (the second parameter) outside the range

 **           of 0 through N-1 (where N is the first parameter)

 **           regardless of the length of the string

 **           requested by the format specification.

 */

 char *sqlite3_mprintf(const char*,...);

 char *sqlite3_vmprintf(const char*, va_list);

 char *sqlite3_snprintf(int,char*,const char*, ...);

 /*

 ** CAPI3REF: Memory Allocation Subsystem {H17300} <S20000>

 **

 ** The SQLite core  uses these three routines for all of its own

 ** internal memory allocation needs. "Core" in the previous sentence

 ** does not include operating-system specific VFS implementation.  The

 ** Windows VFS uses native malloc() and free() for some operations.

 **

 ** The sqlite3_malloc() routine returns a pointer to a block

 ** of memory at least N bytes in length, where N is the parameter.

 ** If sqlite3_malloc() is unable to obtain sufficient free

 ** memory, it returns a NULL pointer.  If the parameter N to

 ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns

 ** a NULL pointer.

 **

 ** Calling sqlite3_free() with a pointer previously returned

 ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so

 ** that it might be reused.  The sqlite3_free() routine is

 ** a no-op if is called with a NULL pointer.  Passing a NULL pointer

 ** to sqlite3_free() is harmless.  After being freed, memory

 ** should neither be read nor written.  Even reading previously freed

 ** memory might result in a segmentation fault or other severe error.

 ** Memory corruption, a segmentation fault, or other severe error

 ** might result if sqlite3_free() is called with a non-NULL pointer that

 ** was not obtained from sqlite3_malloc() or sqlite3_free().

 **

 ** The sqlite3_realloc() interface attempts to resize a

 ** prior memory allocation to be at least N bytes, where N is the

 ** second parameter.  The memory allocation to be resized is the first

 ** parameter.  If the first parameter to sqlite3_realloc()

 ** is a NULL pointer then its behavior is identical to calling

 ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().

 ** If the second parameter to sqlite3_realloc() is zero or

 ** negative then the behavior is exactly the same as calling

 ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().

 ** sqlite3_realloc() returns a pointer to a memory allocation

 ** of at least N bytes in size or NULL if sufficient memory is unavailable.

 ** If M is the size of the prior allocation, then min(N,M) bytes

 ** of the prior allocation are copied into the beginning of buffer returned

 ** by sqlite3_realloc() and the prior allocation is freed.

 ** If sqlite3_realloc() returns NULL, then the prior allocation

 ** is not freed.

 **

 ** The memory returned by sqlite3_malloc() and sqlite3_realloc()

 ** is always aligned to at least an 8 byte boundary. {END}

 **

 ** The default implementation of the memory allocation subsystem uses

 ** the malloc(), realloc() and free() provided by the standard C library.

 ** {H17382} However, if SQLite is compiled with the

 ** SQLITE_MEMORY_SIZE=<i>NNN</i> C preprocessor macro (where <i>NNN</i>

 ** is an integer), then SQLite create a static array of at least

 ** <i>NNN</i> bytes in size and uses that array for all of its dynamic

 ** memory allocation needs. {END}  Additional memory allocator options

 ** may be added in future releases.

 **

 ** In SQLite version 3.5.0 and 3.5.1, it was possible to define

 ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in

 ** implementation of these routines to be omitted.  That capability

 ** is no longer provided.  Only built-in memory allocators can be used.

 **

 ** The Windows OS interface layer calls

 ** the system malloc() and free() directly when converting

 ** filenames between the UTF-8 encoding used by SQLite

 ** and whatever filename encoding is used by the particular Windows

 ** installation.  Memory allocation errors are detected, but

 ** they are reported back as [SQLITE_CANTOPEN] or

 ** [SQLITE_IOERR] rather than [SQLITE_NOMEM].

 **

 ** INVARIANTS:

 **

 ** {H17303}  The [sqlite3_malloc(N)] interface returns either a pointer to

 **           a newly checked-out block of at least N bytes of memory

 **           that is 8-byte aligned, or it returns NULL if it is unable

 **           to fulfill the request.

 **

 ** {H17304}  The [sqlite3_malloc(N)] interface returns a NULL pointer if

 **           N is less than or equal to zero.

 **

 ** {H17305}  The [sqlite3_free(P)] interface releases memory previously

 **           returned from [sqlite3_malloc()] or [sqlite3_realloc()],

 **           making it available for reuse.

 **

 ** {H17306}  A call to [sqlite3_free(NULL)] is a harmless no-op.

 **

 ** {H17310}  A call to [sqlite3_realloc(0,N)] is equivalent to a call

 **           to [sqlite3_malloc(N)].

 **

 ** {H17312}  A call to [sqlite3_realloc(P,0)] is equivalent to a call

 **           to [sqlite3_free(P)].

 **

 ** {H17315}  The SQLite core uses [sqlite3_malloc()], [sqlite3_realloc()],

 **           and [sqlite3_free()] for all of its memory allocation and

 **           deallocation needs.

 **

 ** {H17318}  The [sqlite3_realloc(P,N)] interface returns either a pointer

 **           to a block of checked-out memory of at least N bytes in size

 **           that is 8-byte aligned, or a NULL pointer.

 **

 ** {H17321}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first

 **           copies the first K bytes of content from P into the newly

 **           allocated block, where K is the lesser of N and the size of

 **           the buffer P.

 **

 ** {H17322}  When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first

 **           releases the buffer P.

 **

 ** {H17323}  When [sqlite3_realloc(P,N)] returns NULL, the buffer P is

 **           not modified or released.

 **

 ** ASSUMPTIONS:

 **

 ** {A17350}  The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]

 **           must be either NULL or else pointers obtained from a prior

 **           invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have

 **           not yet been released.

 **

 ** {A17351}  The application must not read or write any part of

 **           a block of memory after it has been released using

 **           [sqlite3_free()] or [sqlite3_realloc()].

 */

 void *sqlite3_malloc(int);

 void *sqlite3_realloc(void*, int);

 void sqlite3_free(void*);

 /*

 ** CAPI3REF: Memory Allocator Statistics {H17370} <S30210>

 **

 ** SQLite provides these two interfaces for reporting on the status

 ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]

 ** routines, which form the built-in memory allocation subsystem.

 **

 ** INVARIANTS:

 **

 ** {H17371} The [sqlite3_memory_used()] routine returns the number of bytes

 **          of memory currently outstanding (malloced but not freed).

 **

 ** {H17373} The [sqlite3_memory_highwater()] routine returns the maximum

 **          value of [sqlite3_memory_used()] since the high-water mark

 **          was last reset.

 **

 ** {H17374} The values returned by [sqlite3_memory_used()] and

 **          [sqlite3_memory_highwater()] include any overhead

 **          added by SQLite in its implementation of [sqlite3_malloc()],

 **          but not overhead added by the any underlying system library

 **          routines that [sqlite3_malloc()] may call.

 **

 ** {H17375} The memory high-water mark is reset to the current value of

 **          [sqlite3_memory_used()] if and only if the parameter to

 **          [sqlite3_memory_highwater()] is true.  The value returned

 **          by [sqlite3_memory_highwater(1)] is the high-water mark

 **          prior to the reset.

 */

 sqlite3_int64 sqlite3_memory_used(void);

 sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

 /*

 ** CAPI3REF: Pseudo-Random Number Generator {H17390} <S20000>

 **

 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to

 ** select random ROWIDs when inserting new records into a table that

 ** already uses the largest possible ROWID.  The PRNG is also used for

 ** the build-in random() and randomblob() SQL functions.  This interface allows

 ** applications to access the same PRNG for other purposes.

 **

 ** A call to this routine stores N bytes of randomness into buffer P.

 **

 ** The first time this routine is invoked (either internally or by

 ** the application) the PRNG is seeded using randomness obtained

 ** from the xRandomness method of the default [sqlite3_vfs] object.

 ** On all subsequent invocations, the pseudo-randomness is generated

 ** internally and without recourse to the [sqlite3_vfs] xRandomness

 ** method.

 **

 ** INVARIANTS:

 **

 ** {H17392} The [sqlite3_randomness(N,P)] interface writes N bytes of

 **          high-quality pseudo-randomness into buffer P.

 */

 void sqlite3_randomness(int N, void *P);

 /*

 ** CAPI3REF: Compile-Time Authorization Callbacks {H12500} <S70100>

 **

 ** This routine registers a authorizer callback with a particular

 ** [database connection], supplied in the first argument.

 ** The authorizer callback is invoked as SQL statements are being compiled

 ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],

 ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  At various

 ** points during the compilation process, as logic is being created

 ** to perform various actions, the authorizer callback is invoked to

 ** see if those actions are allowed.  The authorizer callback should

 ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the

 ** specific action but allow the SQL statement to continue to be

 ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be

 ** rejected with an error.  If the authorizer callback returns

 ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]

 ** then the [sqlite3_prepare_v2()] or equivalent call that triggered

 ** the authorizer will fail with an error message.

 **

 ** When the callback returns [SQLITE_OK], that means the operation

 ** requested is ok.  When the callback returns [SQLITE_DENY], the

 ** [sqlite3_prepare_v2()] or equivalent call that triggered the

 ** authorizer will fail with an error message explaining that

 ** access is denied.  If the authorizer code is [SQLITE_READ]

 ** and the callback returns [SQLITE_IGNORE] then the

 ** [prepared statement] statement is constructed to substitute

 ** a NULL value in place of the table column that would have

 ** been read if [SQLITE_OK] had been returned.  The [SQLITE_IGNORE]

 ** return can be used to deny an untrusted user access to individual

 ** columns of a table.

 **

 ** The first parameter to the authorizer callback is a copy of the third

 ** parameter to the sqlite3_set_authorizer() interface. The second parameter

 ** to the callback is an integer [SQLITE_COPY | action code] that specifies

 ** the particular action to be authorized. The third through sixth parameters

 ** to the callback are zero-terminated strings that contain additional

 ** details about the action to be authorized.

 **

 ** An authorizer is used when [sqlite3_prepare | preparing]

 ** SQL statements from an untrusted source, to ensure that the SQL statements

 ** do not try to access data they are not allowed to see, or that they do not

 ** try to execute malicious statements that damage the database.  For

 ** example, an application may allow a user to enter arbitrary

 ** SQL queries for evaluation by a database.  But the application does

 ** not want the user to be able to make arbitrary changes to the

 ** database.  An authorizer could then be put in place while the

 ** user-entered SQL is being [sqlite3_prepare | prepared] that

 ** disallows everything except [SELECT] statements.

 **

 ** Applications that need to process SQL from untrusted sources

 ** might also consider lowering resource limits using [sqlite3_limit()]

 ** and limiting database size using the [max_page_count] [PRAGMA]

 ** in addition to using an authorizer.

 **

 ** Only a single authorizer can be in place on a database connection

 ** at a time.  Each call to sqlite3_set_authorizer overrides the

 ** previous call.  Disable the authorizer by installing a NULL callback.

 ** The authorizer is disabled by default.

 **

 ** Note that the authorizer callback is invoked only during

 ** [sqlite3_prepare()] or its variants.  Authorization is not

 ** performed during statement evaluation in [sqlite3_step()].

 **

 ** INVARIANTS:

 **

 ** {H12501} The [sqlite3_set_authorizer(D,...)] interface registers a

 **          authorizer callback with database connection D.

 **

 ** {H12502} The authorizer callback is invoked as SQL statements are

 **          being compiled.

 **

 ** {H12503} If the authorizer callback returns any value other than

 **          [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY], then

 **          the [sqlite3_prepare_v2()] or equivalent call that caused

 **          the authorizer callback to run shall fail with an

 **          [SQLITE_ERROR] error code and an appropriate error message.

 **

 ** {H12504} When the authorizer callback returns [SQLITE_OK], the operation

 **          described is processed normally.

 **

 ** {H12505} When the authorizer callback returns [SQLITE_DENY], the

 **          [sqlite3_prepare_v2()] or equivalent call that caused the

 **          authorizer callback to run shall fail

 **          with an [SQLITE_ERROR] error code and an error message

 **          explaining that access is denied.

 **

 ** {H12506} If the authorizer code (the 2nd parameter to the authorizer

 **          callback) is [SQLITE_READ] and the authorizer callback returns

 **          [SQLITE_IGNORE], then the prepared statement is constructed to

 **          insert a NULL value in place of the table column that would have

 **          been read if [SQLITE_OK] had been returned.

 **

 ** {H12507} If the authorizer code (the 2nd parameter to the authorizer

 **          callback) is anything other than [SQLITE_READ], then

 **          a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY].

 **

 ** {H12510} The first parameter to the authorizer callback is a copy of

 **          the third parameter to the [sqlite3_set_authorizer()] interface.

 **

 ** {H12511} The second parameter to the callback is an integer

 **          [SQLITE_COPY | action code] that specifies the particular action

 **          to be authorized.

 **

 ** {H12512} The third through sixth parameters to the callback are

 **          zero-terminated strings that contain

 **          additional details about the action to be authorized.

 **

 ** {H12520} Each call to [sqlite3_set_authorizer()] overrides

 **          any previously installed authorizer.

 **

 ** {H12521} A NULL authorizer means that no authorization

 **          callback is invoked.

 **

 ** {H12522} The default authorizer is NULL.

 */

 int sqlite3_set_authorizer(

   sqlite3*,

   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),

   void *pUserData

 );

 /*

 ** CAPI3REF: Authorizer Return Codes {H12590} <H12500>

 **

 ** The [sqlite3_set_authorizer | authorizer callback function] must

 ** return either [SQLITE_OK] or one of these two constants in order

 ** to signal SQLite whether or not the action is permitted.  See the

 ** [sqlite3_set_authorizer | authorizer documentation] for additional

 ** information.

 */

 #define SQLITE_DENY   1   /* Abort the SQL statement with an error */

 #define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */

 /*

 ** CAPI3REF: Authorizer Action Codes {H12550} <H12500>

 **

 ** The [sqlite3_set_authorizer()] interface registers a callback function

 ** that is invoked to authorize certain SQL statement actions.  The

 ** second parameter to the callback is an integer code that specifies

 ** what action is being authorized.  These are the integer action codes that

 ** the authorizer callback may be passed.

 **

 ** These action code values signify what kind of operation is to be

 ** authorized.  The 3rd and 4th parameters to the authorization

 ** callback function will be parameters or NULL depending on which of these

 ** codes is used as the second parameter.  The 5th parameter to the

 ** authorizer callback is the name of the database ("main", "temp",

 ** etc.) if applicable.  The 6th parameter to the authorizer callback

 ** is the name of the inner-most trigger or view that is responsible for

 ** the access attempt or NULL if this access attempt is directly from

 ** top-level SQL code.

 **

 ** INVARIANTS:

 **

 ** {H12551} The second parameter to an

 **          [sqlite3_set_authorizer | authorizer callback] is always an integer

 **          [SQLITE_COPY | authorizer code] that specifies what action

 **          is being authorized.

 **

 ** {H12552} The 3rd and 4th parameters to the

 **          [sqlite3_set_authorizer | authorization callback]

 **          will be parameters or NULL depending on which

 **          [SQLITE_COPY | authorizer code] is used as the second parameter.

 **

 ** {H12553} The 5th parameter to the

 **          [sqlite3_set_authorizer | authorizer callback] is the name

 **          of the database (example: "main", "temp", etc.) if applicable.

 **

 ** {H12554} The 6th parameter to the

 **          [sqlite3_set_authorizer | authorizer callback] is the name

 **          of the inner-most trigger or view that is responsible for

 **          the access attempt or NULL if this access attempt is directly from

 **          top-level SQL code.

 */

 /******************************************* 3rd ************ 4th ***********/

 #define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */

 #define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */

 #define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */

 #define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */

 #define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */

 #define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */

 #define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */

 #define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */

 #define SQLITE_DELETE                9   /* Table Name      NULL            */

 #define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */

 #define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */

 #define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */

 #define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */

 #define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */

 #define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */

 #define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */

 #define SQLITE_DROP_VIEW            17   /* View Name       NULL            */

 #define SQLITE_INSERT               18   /* Table Name      NULL            */

 #define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */

 #define SQLITE_READ                 20   /* Table Name      Column Name     */

 #define SQLITE_SELECT               21   /* NULL            NULL            */

 #define SQLITE_TRANSACTION          22   /* NULL            NULL            */

 #define SQLITE_UPDATE               23   /* Table Name      Column Name     */

 #define SQLITE_ATTACH               24   /* Filename        NULL            */

 #define SQLITE_DETACH               25   /* Database Name   NULL            */

 #define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */

 #define SQLITE_REINDEX              27   /* Index Name      NULL            */

 #define SQLITE_ANALYZE              28   /* Table Name      NULL            */

 #define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */

 #define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */

 #define SQLITE_FUNCTION             31   /* Function Name   NULL            */

 #define SQLITE_COPY                  0   /* No longer used */

 /*

 ** CAPI3REF: Tracing And Profiling Functions {H12280} <S60400>

 ** EXPERIMENTAL

 **

 ** These routines register callback functions that can be used for

 ** tracing and profiling the execution of SQL statements.

 **

 ** The callback function registered by sqlite3_trace() is invoked at

 ** various times when an SQL statement is being run by [sqlite3_step()].

 ** The callback returns a UTF-8 rendering of the SQL statement text

 ** as the statement first begins executing.  Additional callbacks occur

 ** as each triggered subprogram is entered.  The callbacks for triggers

 ** contain a UTF-8 SQL comment that identifies the trigger.

 **

 ** The callback function registered by sqlite3_profile() is invoked

 ** as each SQL statement finishes.  The profile callback contains

 ** the original statement text and an estimate of wall-clock time

 ** of how long that statement took to run.

 **

 ** INVARIANTS:

 **

 ** {H12281} The callback function registered by [sqlite3_trace()] is

 **          whenever an SQL statement first begins to execute and

 **          whenever a trigger subprogram first begins to run.

 **

 ** {H12282} Each call to [sqlite3_trace()] overrides the previously

 **          registered trace callback.

 **

 ** {H12283} A NULL trace callback disables tracing.

 **

 ** {H12284} The first argument to the trace callback is a copy of

 **          the pointer which was the 3rd argument to [sqlite3_trace()].

 **

 ** {H12285} The second argument to the trace callback is a

 **          zero-terminated UTF-8 string containing the original text

 **          of the SQL statement as it was passed into [sqlite3_prepare_v2()]

 **          or the equivalent, or an SQL comment indicating the beginning

 **          of a trigger subprogram.

 **

 ** {H12287} The callback function registered by [sqlite3_profile()] is invoked

 **          as each SQL statement finishes.

 **

 ** {H12288} The first parameter to the profile callback is a copy of

 **          the 3rd parameter to [sqlite3_profile()].

 **

 ** {H12289} The second parameter to the profile callback is a

 **          zero-terminated UTF-8 string that contains the complete text of

 **          the SQL statement as it was processed by [sqlite3_prepare_v2()]

 **          or the equivalent.

 **

 ** {H12290} The third parameter to the profile callback is an estimate

 **          of the number of nanoseconds of wall-clock time required to

 **          run the SQL statement from start to finish.

 */

 void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);

 void *sqlite3_profile(sqlite3*,

    void(*xProfile)(void*,const char*,sqlite3_uint64), void*);

 /*

 ** CAPI3REF: Query Progress Callbacks {H12910} <S60400>

 **

 ** This routine configures a callback function - the

 ** progress callback - that is invoked periodically during long

 ** running calls to [sqlite3_exec()], [sqlite3_step()] and

 ** [sqlite3_get_table()].  An example use for this

 ** interface is to keep a GUI updated during a large query.

 **

 ** If the progress callback returns non-zero, the operation is

 ** interrupted.  This feature can be used to implement a

 ** "Cancel" button on a GUI dialog box.

 **

 ** INVARIANTS:

 **

 ** {H12911} The callback function registered by sqlite3_progress_handler()

 **          is invoked periodically during long running calls to

 **          [sqlite3_step()].

 **

 ** {H12912} The progress callback is invoked once for every N virtual

 **          machine opcodes, where N is the second argument to

 **          the [sqlite3_progress_handler()] call that registered

 **          the callback.  If N is less than 1, sqlite3_progress_handler()

 **          acts as if a NULL progress handler had been specified.

 **

 ** {H12913} The progress callback itself is identified by the third

 **          argument to sqlite3_progress_handler().

 **

 ** {H12914} The fourth argument to sqlite3_progress_handler() is a

 **          void pointer passed to the progress callback

 **          function each time it is invoked.

 **

 ** {H12915} If a call to [sqlite3_step()] results in fewer than N opcodes

 **          being executed, then the progress callback is never invoked.

 **

 ** {H12916} Every call to [sqlite3_progress_handler()]

 **          overwrites any previously registered progress handler.

 **

 ** {H12917} If the progress handler callback is NULL then no progress

 **          handler is invoked.

 **

 ** {H12918} If the progress callback returns a result other than 0, then

 **          the behavior is a if [sqlite3_interrupt()] had been called.

 **          <S30500>

 */

 void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

 /*

 ** CAPI3REF: Opening A New Database Connection {H12700} <S40200>

 **

 ** These routines open an SQLite database file whose name is given by the

 ** filename argument. The filename argument is interpreted as UTF-8 for

 ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte

 ** order for sqlite3_open16(). A [database connection] handle is usually

 ** returned in *ppDb, even if an error occurs.  The only exception is that

 ** if SQLite is unable to allocate memory to hold the [sqlite3] object,

 ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]

 ** object. If the database is opened (and/or created) successfully, then

 ** [SQLITE_OK] is returned.  Otherwise an [error code] is returned.  The

 ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain

 ** an English language description of the error.

 **

 ** The default encoding for the database will be UTF-8 if

 ** sqlite3_open() or sqlite3_open_v2() is called and

 ** UTF-16 in the native byte order if sqlite3_open16() is used.

 **

 ** Whether or not an error occurs when it is opened, resources

 ** associated with the [database connection] handle should be released by

 ** passing it to [sqlite3_close()] when it is no longer required.

 **

 ** The sqlite3_open_v2() interface works like sqlite3_open()

 ** except that it accepts two additional parameters for additional control

 ** over the new database connection.  The flags parameter can take one of

 ** the following three values, optionally combined with the 

 ** [SQLITE_OPEN_NOMUTEX] flag:

 **

 ** <dl>

 ** <dt>[SQLITE_OPEN_READONLY]</dt>

 ** <dd>The database is opened in read-only mode.  If the database does not

 ** already exist, an error is returned.</dd>

 **

 ** <dt>[SQLITE_OPEN_READWRITE]</dt>

 ** <dd>The database is opened for reading and writing if possible, or reading

 ** only if the file is write protected by the operating system.  In either

 ** case the database must already exist, otherwise an error is returned.</dd>

 **

 ** <dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>

 ** <dd>The database is opened for reading and writing, and is creates it if

 ** it does not already exist. This is the behavior that is always used for

 ** sqlite3_open() and sqlite3_open16().</dd>

 ** </dl>

 **

 ** If the 3rd parameter to sqlite3_open_v2() is not one of the

 ** combinations shown above or one of the combinations shown above combined

 ** with the [SQLITE_OPEN_NOMUTEX] flag, then the behavior is undefined.

 **

 ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then mutexes on the

 ** opened [database connection] are disabled and the appliation must

 ** insure that access to the [database connection] and its associated

 ** [prepared statements] is serialized.  The [SQLITE_OPEN_NOMUTEX] flag

 ** is the default behavior is SQLite is configured using the

 ** [SQLITE_CONFIG_MULTITHREAD] or [SQLITE_CONFIG_SINGLETHREAD] options

 ** to [sqlite3_config()].  The [SQLITE_OPEN_NOMUTEX] flag only makes a

 ** difference when SQLite is in its default [SQLITE_CONFIG_SERIALIZED] mode.

 **

 ** If the filename is ":memory:", then a private, temporary in-memory database

 ** is created for the connection.  This in-memory database will vanish when

 ** the database connection is closed.  Future versions of SQLite might

 ** make use of additional special filenames that begin with the ":" character.

 ** It is recommended that when a database filename actually does begin with

 ** a ":" character you should prefix the filename with a pathname such as

 ** "./" to avoid ambiguity.

 **

 ** If the filename is an empty string, then a private, temporary

 ** on-disk database will be created.  This private database will be

 ** automatically deleted as soon as the database connection is closed.

 **

 ** The fourth parameter to sqlite3_open_v2() is the name of the

 ** [sqlite3_vfs] object that defines the operating system interface that

 ** the new database connection should use.  If the fourth parameter is

 ** a NULL pointer then the default [sqlite3_vfs] object is used.

 **

 ** <b>Note to Windows users:</b>  The encoding used for the filename argument

 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever

 ** codepage is currently defined.  Filenames containing international

 ** characters must be converted to UTF-8 prior to passing them into

 ** sqlite3_open() or sqlite3_open_v2().

 **

 ** INVARIANTS:

 **

 ** {H12701} The [sqlite3_open()], [sqlite3_open16()], and

 **          [sqlite3_open_v2()] interfaces create a new

 **          [database connection] associated with

 **          the database file given in their first parameter.

 **

 ** {H12702} The filename argument is interpreted as UTF-8

 **          for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16

 **          in the native byte order for [sqlite3_open16()].

 **

 ** {H12703} A successful invocation of [sqlite3_open()], [sqlite3_open16()],

 **          or [sqlite3_open_v2()] writes a pointer to a new

 **          [database connection] into *ppDb.

 **

 ** {H12704} The [sqlite3_open()], [sqlite3_open16()], and

 **          [sqlite3_open_v2()] interfaces return [SQLITE_OK] upon success,

 **          or an appropriate [error code] on failure.

 **

 ** {H12706} The default text encoding for a new database created using

 **          [sqlite3_open()] or [sqlite3_open_v2()] will be UTF-8.

 **

 ** {H12707} The default text encoding for a new database created using

 **          [sqlite3_open16()] will be UTF-16.

 **

 ** {H12709} The [sqlite3_open(F,D)] interface is equivalent to

 **          [sqlite3_open_v2(F,D,G,0)] where the G parameter is

 **          [SQLITE_OPEN_READWRITE]|[SQLITE_OPEN_CREATE].

 **

 ** {H12711} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the

 **          bit value [SQLITE_OPEN_READONLY] then the database is opened

 **          for reading only.

 **

 ** {H12712} If the G parameter to [sqlite3_open_v2(F,D,G,V)] contains the

 **          bit value [SQLITE_OPEN_READWRITE] then the database is opened

 **          reading and writing if possible, or for reading only if the

 **          file is write protected by the operating system.

 **

 ** {H12713} If the G parameter to [sqlite3_open(v2(F,D,G,V)] omits the

 **          bit value [SQLITE_OPEN_CREATE] and the database does not

 **          previously exist, an error is returned.

 **

 ** {H12714} If the G parameter to [sqlite3_open(v2(F,D,G,V)] contains the

 **          bit value [SQLITE_OPEN_CREATE] and the database does not

 **          previously exist, then an attempt is made to create and

 **          initialize the database.

 **

 ** {H12717} If the filename argument to [sqlite3_open()], [sqlite3_open16()],

 **          or [sqlite3_open_v2()] is ":memory:", then an private,

 **          ephemeral, in-memory database is created for the connection.

 **          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required

 **          in sqlite3_open_v2()?</todo>

 **

 ** {H12719} If the filename is NULL or an empty string, then a private,

 **          ephemeral on-disk database will be created.

 **          <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required

 **          in sqlite3_open_v2()?</todo>

 **

 ** {H12721} The [database connection] created by [sqlite3_open_v2(F,D,G,V)]

 **          will use the [sqlite3_vfs] object identified by the V parameter,

 **          or the default [sqlite3_vfs] object if V is a NULL pointer.

 **

 ** {H12723} Two [database connections] will share a common cache if both were

 **          opened with the same VFS while [shared cache mode] was enabled and

 **          if both filenames compare equal using memcmp() after having been

 **          processed by the [sqlite3_vfs | xFullPathname] method of the VFS.

 */

 int sqlite3_open(

   const char *filename,   /* Database filename (UTF-8) */

   sqlite3 **ppDb          /* OUT: SQLite db handle */

 );

 int sqlite3_open16(

   const void *filename,   /* Database filename (UTF-16) */

   sqlite3 **ppDb          /* OUT: SQLite db handle */

 );

 int sqlite3_open_v2(

   const char *filename,   /* Database filename (UTF-8) */

   sqlite3 **ppDb,         /* OUT: SQLite db handle */

   int flags,              /* Flags */

   const char *zVfs        /* Name of VFS module to use */

 );

 /*

 ** CAPI3REF: Error Codes And Messages {H12800} <S60200>

 **

 ** The sqlite3_errcode() interface returns the numeric [result code] or

 ** [extended result code] for the most recent failed sqlite3_* API call

 ** associated with a [database connection]. If a prior API call failed

 ** but the most recent API call succeeded, the return value from

 ** sqlite3_errcode() is undefined.

 **

 ** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language

 ** text that describes the error, as either UTF-8 or UTF-16 respectively.

 ** Memory to hold the error message string is managed internally.

 ** The application does not need to worry about freeing the result.

 ** However, the error string might be overwritten or deallocated by

 ** subsequent calls to other SQLite interface functions.

 **

 ** If an interface fails with SQLITE_MISUSE, that means the interface

 ** was invoked incorrectly by the application.  In that case, the

 ** error code and message may or may not be set.

 **

 ** INVARIANTS:

 **

 ** {H12801} The [sqlite3_errcode(D)] interface returns the numeric

 **          [result code] or [extended result code] for the most recently

 **          failed interface call associated with the [database connection] D.

 **

 ** {H12803} The [sqlite3_errmsg(D)] and [sqlite3_errmsg16(D)]

 **          interfaces return English-language text that describes

 **          the error in the mostly recently failed interface call,

 **          encoded as either UTF-8 or UTF-16 respectively.

 **

 ** {H12807} The strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]

 **          are valid until the next SQLite interface call.

 **

 ** {H12808} Calls to API routines that do not return an error code

 **          (example: [sqlite3_data_count()]) do not

 **          change the error code or message returned by

 **          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].

 **

 ** {H12809} Interfaces that are not associated with a specific

 **          [database connection] (examples:

 **          [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()]

 **          do not change the values returned by

 **          [sqlite3_errcode()], [sqlite3_errmsg()], or [sqlite3_errmsg16()].

 */

 int sqlite3_errcode(sqlite3 *db);

 const char *sqlite3_errmsg(sqlite3*);

 const void *sqlite3_errmsg16(sqlite3*);

 /*

 ** CAPI3REF: SQL Statement Object {H13000} <H13010>

 ** KEYWORDS: {prepared statement} {prepared statements}

 **

 ** An instance of this object represents a single SQL statement.

 ** This object is variously known as a "prepared statement" or a

 ** "compiled SQL statement" or simply as a "statement".

 **

 ** The life of a statement object goes something like this:

 **

 ** <ol>

 ** <li> Create the object using [sqlite3_prepare_v2()] or a related

 **      function.

 ** <li> Bind values to [host parameters] using the sqlite3_bind_*()

 **      interfaces.

 ** <li> Run the SQL by calling [sqlite3_step()] one or more times.

 ** <li> Reset the statement using [sqlite3_reset()] then go back

 **      to step 2.  Do this zero or more times.

 ** <li> Destroy the object using [sqlite3_finalize()].

 ** </ol>

 **

 ** Refer to documentation on individual methods above for additional

 ** information.

 */

 typedef struct sqlite3_stmt sqlite3_stmt;

 /*

 ** CAPI3REF: Run-time Limits {H12760} <S20600>

 **

 ** This interface allows the size of various constructs to be limited

 ** on a connection by connection basis.  The first parameter is the

 ** [database connection] whose limit is to be set or queried.  The

 ** second parameter is one of the [limit categories] that define a

 ** class of constructs to be size limited.  The third parameter is the

 ** new limit for that construct.  The function returns the old limit.

 **

 ** If the new limit is a negative number, the limit is unchanged.

 ** For the limit category of SQLITE_LIMIT_XYZ there is a hard upper

 ** bound set by a compile-time C preprocessor macro named SQLITE_MAX_XYZ.

 ** (The "_LIMIT_" in the name is changed to "_MAX_".)

 ** Attempts to increase a limit above its hard upper bound are

 ** silently truncated to the hard upper limit.

 **

 ** Run time limits are intended for use in applications that manage

 ** both their own internal database and also databases that are controlled

 ** by untrusted external sources.  An example application might be a

 ** webbrowser that has its own databases for storing history and

 ** separate databases controlled by JavaScript applications downloaded

 ** off the Internet.  The internal databases can be given the

 ** large, default limits.  Databases managed by external sources can

 ** be given much smaller limits designed to prevent a denial of service

 ** attack.  Developers might also want to use the [sqlite3_set_authorizer()]

 ** interface to further control untrusted SQL.  The size of the database

 ** created by an untrusted script can be contained using the

 ** [max_page_count] [PRAGMA].

 **

 ** New run-time limit categories may be added in future releases.

 **

 ** INVARIANTS:

 **

 ** {H12762} A successful call to [sqlite3_limit(D,C,V)] where V is

 **          positive changes the limit on the size of construct C in the

 **          [database connection] D to the lesser of V and the hard upper

 **          bound on the size of C that is set at compile-time.

 **

 ** {H12766} A successful call to [sqlite3_limit(D,C,V)] where V is negative

 **          leaves the state of the [database connection] D unchanged.

 **

 ** {H12769} A successful call to [sqlite3_limit(D,C,V)] returns the

 **          value of the limit on the size of construct C in the

 **          [database connection] D as it was prior to the call.

 */

 int sqlite3_limit(sqlite3*, int id, int newVal);

 /*

 ** CAPI3REF: Run-Time Limit Categories {H12790} <H12760>

 ** KEYWORDS: {limit category} {limit categories}

 **

 ** These constants define various aspects of a [database connection]

 ** that can be limited in size by calls to [sqlite3_limit()].

 ** The meanings of the various limits are as follows:

 **

 ** <dl>

 ** <dt>SQLITE_LIMIT_LENGTH</dt>

 ** <dd>The maximum size of any string or BLOB or table row.<dd>

 **

 ** <dt>SQLITE_LIMIT_SQL_LENGTH</dt>

 ** <dd>The maximum length of an SQL statement.</dd>

 **

 ** <dt>SQLITE_LIMIT_COLUMN</dt>

 ** <dd>The maximum number of columns in a table definition or in the

 ** result set of a SELECT or the maximum number of columns in an index

 ** or in an ORDER BY or GROUP BY clause.</dd>

 **

 ** <dt>SQLITE_LIMIT_EXPR_DEPTH</dt>

 ** <dd>The maximum depth of the parse tree on any expression.</dd>

 **

 ** <dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>

 ** <dd>The maximum number of terms in a compound SELECT statement.</dd>

 **

 ** <dt>SQLITE_LIMIT_VDBE_OP</dt>

 ** <dd>The maximum number of instructions in a virtual machine program

 ** used to implement an SQL statement.</dd>

 **

 ** <dt>SQLITE_LIMIT_FUNCTION_ARG</dt>

 ** <dd>The maximum number of arguments on a function.</dd>

 **

 ** <dt>SQLITE_LIMIT_ATTACHED</dt>