+ **
+ ** 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:
+ **
+ **
+ ** char *zText = "It's a happy day!";
+ **
+ **
+ ** One can use this text in an SQL statement as follows:
+ **
+ **
+ ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+ ** sqlite3_exec(db, zSQL, 0, 0, 0);
+ ** sqlite3_free(zSQL);
+ **
+ **
+ ** Because the %q format string is used, the '\'' character in zText
+ ** is escaped and the SQL generated is as follows:
+ **
+ **
+ ** INSERT INTO table1 VALUES('It''s a happy day!')
+ **
+ **
+ ** This is correct. Had we used %s instead of %q, the generated SQL
+ ** would have looked like this:
+ **
+ **
+ ** INSERT INTO table1 VALUES('It's a happy day!');
+ **
+ **
+ ** This second example is an SQL syntax error. As a general rule you should
+ ** always use %q instead of %s when inserting text into a string literal.
+ **
+ ** The %Q option works like %q except it also adds single quotes around
+ ** the outside of the total string. Additionally, if the parameter in the
+ ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
+ ** single quotes) in place of the %Q option. So, for example, one could say:
+ **
+ **
+ ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+ ** sqlite3_exec(db, zSQL, 0, 0, 0);
+ ** sqlite3_free(zSQL);
+ **
+ **
+ ** The code above will render a correct SQL statement in the zSQL
+ ** variable even if the zText variable is a NULL pointer.
+ **
+ ** The "%z" formatting option works 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}
+ **
+ ** Requirements:
+ ** [H17403] [H17406] [H17407]
+ */
+ //SQLITE_API char *sqlite3_mprintf(const char*,...);
+ //SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
+ //SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
+
+ /*
+ ** CAPI3REF: Memory Allocation Subsystem {H17300}
+ **
+ ** The SQLite core uses these three routines for all of its own
+ ** internal memory allocation needs. "Core" in the previous sentence
+ ** does not include operating-system specific VFS implementation. The
+ ** Windows VFS uses native malloc() and free() for some operations.
+ **
+ ** The sqlite3_malloc() routine returns a pointer to a block
+ ** of memory at least N bytes in length, where N is the parameter.
+ ** If sqlite3_malloc() is unable to obtain sufficient free
+ ** memory, it returns a NULL pointer. If the parameter N to
+ ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
+ ** a NULL pointer.
+ **
+ ** Calling sqlite3_free() with a pointer previously returned
+ ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
+ ** that it might be reused. The sqlite3_free() routine is
+ ** a no-op if is called with a NULL pointer. Passing a NULL pointer
+ ** to sqlite3_free() is harmless. After being freed, memory
+ ** should neither be read nor written. Even reading previously freed
+ ** memory might result in a segmentation fault or other severe error.
+ ** Memory corruption, a segmentation fault, or other severe error
+ ** might result if sqlite3_free() is called with a non-NULL pointer that
+ ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
+ **
+ ** The sqlite3_realloc() interface attempts to resize a
+ ** prior memory allocation to be at least N bytes, where N is the
+ ** second parameter. The memory allocation to be resized is the first
+ ** parameter. If the first parameter to sqlite3_realloc()
+ ** is a NULL pointer then its behavior is identical to calling
+ ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
+ ** If the second parameter to sqlite3_realloc() is zero or
+ ** negative then the behavior is exactly the same as calling
+ ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
+ ** sqlite3_realloc() returns a pointer to a memory allocation
+ ** of at least N bytes in size or NULL if sufficient memory is unavailable.
+ ** If M is the size of the prior allocation, then min(N,M) bytes
+ ** of the prior allocation are copied into the beginning of buffer returned
+ ** by sqlite3_realloc() and the prior allocation is freed.
+ ** If sqlite3_realloc() returns NULL, then the prior allocation
+ ** is not freed.
+ **
+ ** The memory returned by sqlite3_malloc() and sqlite3_realloc()
+ ** is always aligned to at least an 8 byte boundary. {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=NNN C preprocessor macro (where NNN
+ ** is an integer), then SQLite create a static array of at least
+ ** NNN 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].
+ **
+ ** Requirements:
+ ** [H17303] [H17304] [H17305] [H17306] [H17310] [H17312] [H17315] [H17318]
+ ** [H17321] [H17322] [H17323]
+ **
+ ** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
+ ** must be either NULL or else pointers obtained from a prior
+ ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
+ ** not yet been released.
+ **
+ ** The application must not read or write any part of
+ ** a block of memory after it has been released using
+ ** [sqlite3_free()] or [sqlite3_realloc()].
+ */
+ //SQLITE_API void *sqlite3_malloc(int);
+ //SQLITE_API void *sqlite3_realloc(void*, int);
+ //SQLITE_API void sqlite3_free(void*);
+
+ /*
+ ** CAPI3REF: Memory Allocator Statistics {H17370}
+ **
+ ** 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.
+ **
+ ** Requirements:
+ ** [H17371] [H17373] [H17374] [H17375]
+ */
+ //SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
+ //SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
+
+ /*
+ ** CAPI3REF: Pseudo-Random Number Generator {H17390}
+ **
+ ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
+ ** select random [ROWID | ROWIDs] when inserting new records into a table that
+ ** already uses the largest possible [ROWID]. The PRNG is also used for
+ ** the build-in random() and randomblob() SQL functions. This interface allows
+ ** applications to access the same PRNG for other purposes.
+ **
+ ** A call to this routine stores N bytes of randomness into buffer P.
+ **
+ ** The first time this routine is invoked (either internally or by
+ ** the application) the PRNG is seeded using randomness obtained
+ ** from the xRandomness method of the default [sqlite3_vfs] object.
+ ** On all subsequent invocations, the pseudo-randomness is generated
+ ** internally and without recourse to the [sqlite3_vfs] xRandomness
+ ** method.
+ **
+ ** Requirements:
+ ** [H17392]
+ */
+ //SQLITE_API void sqlite3_randomness(int N, void *P);
+
+ /*
+ ** CAPI3REF: Compile-Time Authorization Callbacks {H12500}
+ **
+ ** This routine registers a authorizer callback with a particular
+ ** [database connection], supplied in the first argument.
+ ** The authorizer callback is invoked as SQL statements are being compiled
+ ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
+ ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. At various
+ ** points during the compilation process, as logic is being created
+ ** to perform various actions, the authorizer callback is invoked to
+ ** see if those actions are allowed. The authorizer callback should
+ ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
+ ** specific action but allow the SQL statement to continue to be
+ ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
+ ** rejected with an error. If the authorizer callback returns
+ ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
+ ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
+ ** the authorizer will fail with an error message.
+ **
+ ** When the callback returns [SQLITE_OK], that means the operation
+ ** requested is ok. When the callback returns [SQLITE_DENY], the
+ ** [sqlite3_prepare_v2()] or equivalent call that triggered the
+ ** authorizer will fail with an error message explaining that
+ ** access is denied.
+ **
+ ** The first parameter to the authorizer callback is a copy of the third
+ ** parameter to the sqlite3_set_authorizer() interface. The second parameter
+ ** to the callback is an integer [SQLITE_COPY | action code] that specifies
+ ** the particular action to be authorized. The third through sixth parameters
+ ** to the callback are zero-terminated strings that contain additional
+ ** details about the action to be authorized.
+ **
+ ** If the action code is [SQLITE_READ]
+ ** and the callback returns [SQLITE_IGNORE] then the
+ ** [prepared statement] statement is constructed to substitute
+ ** a NULL value in place of the table column that would have
+ ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
+ ** return can be used to deny an untrusted user access to individual
+ ** columns of a table.
+ ** If the action code is [SQLITE_DELETE] and the callback returns
+ ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
+ ** [truncate optimization] is disabled and all rows are deleted individually.
+ **
+ ** An authorizer is used when [sqlite3_prepare | preparing]
+ ** SQL statements from an untrusted source, to ensure that the SQL statements
+ ** do not try to access data they are not allowed to see, or that they do not
+ ** try to execute malicious statements that damage the database. For
+ ** example, an application may allow a user to enter arbitrary
+ ** SQL queries for evaluation by a database. But the application does
+ ** not want the user to be able to make arbitrary changes to the
+ ** database. An authorizer could then be put in place while the
+ ** user-entered SQL is being [sqlite3_prepare | prepared] that
+ ** disallows everything except [SELECT] statements.
+ **
+ ** Applications that need to process SQL from untrusted sources
+ ** might also consider lowering resource limits using [sqlite3_limit()]
+ ** and limiting database size using the [max_page_count] [PRAGMA]
+ ** in addition to using an authorizer.
+ **
+ ** Only a single authorizer can be in place on a database connection
+ ** at a time. Each call to sqlite3_set_authorizer overrides the
+ ** previous call. Disable the authorizer by installing a NULL callback.
+ ** The authorizer is disabled by default.
+ **
+ ** The authorizer callback must not do anything that will modify
+ ** the database connection that invoked the authorizer callback.
+ ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
+ ** database connections for the meaning of "modify" in this paragraph.
+ **
+ ** When [sqlite3_prepare_v2()] is used to prepare a statement, the
+ ** statement might be reprepared during [sqlite3_step()] due to a
+ ** schema change. Hence, the application should ensure that the
+ ** correct authorizer callback remains in place during the [sqlite3_step()].
+ **
+ ** Note that the authorizer callback is invoked only during
+ ** [sqlite3_prepare()] or its variants. Authorization is not
+ ** performed during statement evaluation in [sqlite3_step()], unless
+ ** as stated in the previous paragraph, sqlite3_step() invokes
+ ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
+ **
+ ** Requirements:
+ ** [H12501] [H12502] [H12503] [H12504] [H12505] [H12506] [H12507] [H12510]
+ ** [H12511] [H12512] [H12520] [H12521] [H12522]
+ */
+ //SQLITE_API int sqlite3_set_authorizer(
+ // sqlite3*,
+ // int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
+ // void *pUserData
+ //);
+
+ /*
+ ** CAPI3REF: Authorizer Return Codes {H12590}
+ **
+ ** 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 */
+ const int SQLITE_DENY = 1;
+ const int SQLITE_IGNORE = 2;
+
+ /*
+ ** CAPI3REF: Authorizer Action Codes {H12550}
+ **
+ ** 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.
+ **
+ ** Requirements:
+ ** [H12551] [H12552] [H12553] [H12554]
+ */
+ /******************************************* 3rd ************ 4th ***********/
+ //#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */
+ //#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */
+ //#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */
+ //#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */
+ //#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */
+ //#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */
+ //#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */
+ //#define SQLITE_CREATE_VIEW 8 /* View Name NULL */
+ //#define SQLITE_DELETE 9 /* Table Name NULL */
+ //#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */
+ //#define SQLITE_DROP_TABLE 11 /* Table Name NULL */
+ //#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */
+ //#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */
+ //#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */
+ //#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */
+ //#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */
+ //#define SQLITE_DROP_VIEW 17 /* View Name NULL */
+ //#define SQLITE_INSERT 18 /* Table Name NULL */
+ //#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */
+ //#define SQLITE_READ 20 /* Table Name Column Name */
+ //#define SQLITE_SELECT 21 /* NULL NULL */
+ //#define SQLITE_TRANSACTION 22 /* Operation NULL */
+ //#define SQLITE_UPDATE 23 /* Table Name Column Name */
+ //#define SQLITE_ATTACH 24 /* Filename NULL */
+ //#define SQLITE_DETACH 25 /* Database Name NULL */
+ //#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
+ //#define SQLITE_REINDEX 27 /* Index Name NULL */
+ //#define SQLITE_ANALYZE 28 /* Table Name NULL */
+ //#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */
+ //#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */
+ //#define SQLITE_FUNCTION 31 /* NULL Function Name */
+ //#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */
+ //#define SQLITE_COPY 0 /* No longer used */
+ const int SQLITE_CREATE_INDEX = 1;
+ const int SQLITE_CREATE_TABLE = 2;
+ const int SQLITE_CREATE_TEMP_INDEX = 3;
+ const int SQLITE_CREATE_TEMP_TABLE = 4;
+ const int SQLITE_CREATE_TEMP_TRIGGER = 5;
+ const int SQLITE_CREATE_TEMP_VIEW = 6;
+ const int SQLITE_CREATE_TRIGGER = 7;
+ const int SQLITE_CREATE_VIEW = 8;
+ const int SQLITE_DELETE = 9;
+ const int SQLITE_DROP_INDEX = 10;
+ const int SQLITE_DROP_TABLE = 11;
+ const int SQLITE_DROP_TEMP_INDEX = 12;
+ const int SQLITE_DROP_TEMP_TABLE = 13;
+ const int SQLITE_DROP_TEMP_TRIGGER = 14;
+ const int SQLITE_DROP_TEMP_VIEW = 15;
+ const int SQLITE_DROP_TRIGGER = 16;
+ const int SQLITE_DROP_VIEW = 17;
+ const int SQLITE_INSERT = 18;
+ const int SQLITE_PRAGMA = 19;
+ const int SQLITE_READ = 20;
+ const int SQLITE_SELECT = 21;
+ const int SQLITE_TRANSACTION = 22;
+ const int SQLITE_UPDATE = 23;
+ const int SQLITE_ATTACH = 24;
+ const int SQLITE_DETACH = 25;
+ const int SQLITE_ALTER_TABLE = 26;
+ const int SQLITE_REINDEX = 27;
+ const int SQLITE_ANALYZE = 28;
+ const int SQLITE_CREATE_VTABLE = 29;
+ const int SQLITE_DROP_VTABLE = 30;
+ const int SQLITE_FUNCTION = 31;
+ const int SQLITE_SAVEPOINT = 32;
+ const int SQLITE_COPY = 0;
+
+ /*
+ ** CAPI3REF: Tracing And Profiling Functions {H12280}
+ ** 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.
+ **
+ ** Requirements:
+ ** [H12281] [H12282] [H12283] [H12284] [H12285] [H12287] [H12288] [H12289]
+ ** [H12290]
+ */
+ //SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
+ //SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
+ // void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
+
+ /*
+ ** CAPI3REF: Query Progress Callbacks {H12910}
+ **
+ ** This routine configures a callback function - the
+ ** progress callback - that is invoked periodically during long
+ ** running calls to [sqlite3_exec()], [sqlite3_step()] and
+ ** [sqlite3_get_table()]. An example use for this
+ ** interface is to keep a GUI updated during a large query.
+ **
+ ** If the progress callback returns non-zero, the operation is
+ ** interrupted. This feature can be used to implement a
+ ** "Cancel" button on a GUI progress dialog box.
+ **
+ ** The progress handler must not do anything that will modify
+ ** the database connection that invoked the progress handler.
+ ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
+ ** database connections for the meaning of "modify" in this paragraph.
+ **
+ ** Requirements:
+ ** [H12911] [H12912] [H12913] [H12914] [H12915] [H12916] [H12917] [H12918]
+ **
+ */
+ //SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
+
+ /*
+ ** CAPI3REF: Opening A New Database Connection {H12700}
+ **
+ ** 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] or [SQLITE_OPEN_FULLMUTEX] flags:
+ **
+ **
+ ** - [SQLITE_OPEN_READONLY]
+ ** - The database is opened in read-only mode. If the database does not
+ ** already exist, an error is returned.
+ **
+ ** - [SQLITE_OPEN_READWRITE]
+ ** - The database is opened for reading and writing if possible, or reading
+ ** only if the file is write protected by the operating system. In either
+ ** case the database must already exist, otherwise an error is returned.
+ **
+ ** - [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+ ** - The database is opened for reading and writing, and is creates it if
+ ** it does not already exist. This is the behavior that is always used for
+ ** sqlite3_open() and sqlite3_open16().
+ **
+ **
+ ** If the 3rd parameter to sqlite3_open_v2() is not one of the
+ ** combinations shown above or one of the combinations shown above combined
+ ** with the [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags,
+ ** then the behavior is undefined.
+ **
+ ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
+ ** opens in the multi-thread [threading mode] as long as the single-thread
+ ** mode has not been set at compile-time or start-time. If the
+ ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
+ ** in the serialized [threading mode] unless single-thread was
+ ** previously selected at compile-time or start-time.
+ **
+ ** If the filename is ":memory:", then a private, temporary in-memory database
+ ** is created for the connection. This in-memory database will vanish when
+ ** the database connection is closed. Future versions of SQLite might
+ ** make use of additional special filenames that begin with the ":" character.
+ ** It is recommended that when a database filename actually does begin with
+ ** a ":" character you should prefix the filename with a pathname such as
+ ** "./" to avoid ambiguity.
+ **
+ ** If the filename is an empty string, then a private, temporary
+ ** on-disk database will be created. This private database will be
+ ** automatically deleted as soon as the database connection is closed.
+ **
+ ** The fourth parameter to sqlite3_open_v2() is the name of the
+ ** [sqlite3_vfs] object that defines the operating system interface that
+ ** the new database connection should use. If the fourth parameter is
+ ** a NULL pointer then the default [sqlite3_vfs] object is used.
+ **
+ ** Note to Windows users: The encoding used for the filename argument
+ ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
+ ** codepage is currently defined. Filenames containing international
+ ** characters must be converted to UTF-8 prior to passing them into
+ ** sqlite3_open() or sqlite3_open_v2().
+ **
+ ** Requirements:
+ ** [H12701] [H12702] [H12703] [H12704] [H12706] [H12707] [H12709] [H12711]
+ ** [H12712] [H12713] [H12714] [H12717] [H12719] [H12721] [H12723]
+ */
+ //SQLITE_API int sqlite3_open(
+ // const char *filename, /* Database filename (UTF-8) */
+ // sqlite3 **ppDb /* OUT: SQLite db handle */
+ //);
+ //SQLITE_API int sqlite3_open16(
+ // const void *filename, /* Database filename (UTF-16) */
+ // sqlite3 **ppDb /* OUT: SQLite db handle */
+ //);
+ //SQLITE_API int sqlite3_open_v2(
+ // const char *filename, /* Database filename (UTF-8) */
+ // sqlite3 **ppDb, /* OUT: SQLite db handle */
+ // int flags, /* Flags */
+ // const char *zVfs /* Name of VFS module to use */
+ //);
+
+ /*
+ ** CAPI3REF: Error Codes And Messages {H12800}
+ **
+ ** The sqlite3_errcode() interface returns the numeric [result code] or
+ ** [extended result code] for the most recent failed sqlite3_* API call
+ ** associated with a [database connection]. If a prior API call failed
+ ** but the most recent API call succeeded, the return value from
+ ** sqlite3_errcode() is undefined. The sqlite3_extended_errcode()
+ ** interface is the same except that it always returns the
+ ** [extended result code] even when extended result codes are
+ ** disabled.
+ **
+ ** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
+ ** text that describes the error, as either UTF-8 or UTF-16 respectively.
+ ** Memory to hold the error message string is managed internally.
+ ** The application does not need to worry about freeing the result.
+ ** However, the error string might be overwritten or deallocated by
+ ** subsequent calls to other SQLite interface functions.
+ **
+ ** When the serialized [threading mode] is in use, it might be the
+ ** case that a second error occurs on a separate thread in between
+ ** the time of the first error and the call to these interfaces.
+ ** When that happens, the second error will be reported since these
+ ** interfaces always report the most recent result. To avoid
+ ** this, each thread can obtain exclusive use of the [database connection] D
+ ** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
+ ** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
+ ** all calls to the interfaces listed here are completed.
+ **
+ ** If an interface fails with SQLITE_MISUSE, that means the interface
+ ** was invoked incorrectly by the application. In that case, the
+ ** error code and message may or may not be set.
+ **
+ ** Requirements:
+ ** [H12801] [H12802] [H12803] [H12807] [H12808] [H12809]
+ */
+ //SQLITE_API int sqlite3_errcode(sqlite3 *db);
+ //SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
+ //SQLITE_API const char *sqlite3_errmsg(sqlite3*);
+ //SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
+
+ /*
+ ** CAPI3REF: SQL Statement Object {H13000}
+ ** 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:
+ **
+ **
+ ** - Create the object using [sqlite3_prepare_v2()] or a related
+ ** function.
+ **
- Bind values to [host parameters] using the sqlite3_bind_*()
+ ** interfaces.
+ **
- Run the SQL by calling [sqlite3_step()] one or more times.
+ **
- Reset the statement using [sqlite3_reset()] then go back
+ ** to step 2. Do this zero or more times.
+ **
- Destroy the object using [sqlite3_finalize()].
+ **
+ **
+ ** Refer to documentation on individual methods above for additional
+ ** information.
+ */
+ //typedef struct sqlite3_stmt sqlite3_stmt;
+
+ /*
+ ** CAPI3REF: Run-time Limits {H12760}
+ **
+ ** This interface allows the size of various constructs to be limited
+ ** on a connection by connection basis. The first parameter is the
+ ** [database connection] whose limit is to be set or queried. The
+ ** second parameter is one of the [limit categories] that define a
+ ** class of constructs to be size limited. The third parameter is the
+ ** new limit for that construct. The function returns the old limit.
+ **
+ ** If the new limit is a negative number, the limit is unchanged.
+ ** For the limit category of SQLITE_LIMIT_XYZ there is a
+ ** [limits | hard upper bound]
+ ** set by a compile-time C preprocessor macro named
+ ** [limits | SQLITE_MAX_XYZ].
+ ** (The "_LIMIT_" in the name is changed to "_MAX_".)
+ ** Attempts to increase a limit above its hard upper bound are
+ ** silently truncated to the hard upper 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
+ ** web browser that has its own databases for storing history and
+ ** separate databases controlled by JavaScript applications downloaded
+ ** off the Internet. The internal databases can be given the
+ ** large, default limits. Databases managed by external sources can
+ ** be given much smaller limits designed to prevent a denial of service
+ ** attack. Developers might also want to use the [sqlite3_set_authorizer()]
+ ** interface to further control untrusted SQL. The size of the database
+ ** created by an untrusted script can be contained using the
+ ** [max_page_count] [PRAGMA].
+ **
+ ** New run-time limit categories may be added in future releases.
+ **
+ ** Requirements:
+ ** [H12762] [H12766] [H12769]
+ */
+ //SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
+
+ /*
+ ** CAPI3REF: Run-Time Limit Categories {H12790}
+ ** KEYWORDS: {limit category} {limit categories}
+ **
+ ** These constants define various performance limits
+ ** that can be lowered at run-time using [sqlite3_limit()].
+ ** The synopsis of the meanings of the various limits is shown below.
+ ** Additional information is available at [limits | Limits in SQLite].
+ **
+ **
+ ** - SQLITE_LIMIT_LENGTH
+ ** - The maximum size of any string or BLOB or table row.
-
+ **
+ **
- SQLITE_LIMIT_SQL_LENGTH
+ ** - The maximum length of an SQL statement.
+ **
+ ** - SQLITE_LIMIT_COLUMN
+ ** - The maximum number of columns in a table definition or in the
+ ** result set of a [SELECT] or the maximum number of columns in an index
+ ** or in an ORDER BY or GROUP BY clause.
+ **
+ ** - SQLITE_LIMIT_EXPR_DEPTH
+ ** - The maximum depth of the parse tree on any expression.
+ **
+ ** - SQLITE_LIMIT_COMPOUND_SELECT
+ ** - The maximum number of terms in a compound SELECT statement.
+ **
+ ** - SQLITE_LIMIT_VDBE_OP
+ ** - The maximum number of instructions in a virtual machine program
+ ** used to implement an SQL statement.
+ **
+ ** - SQLITE_LIMIT_FUNCTION_ARG
+ ** - The maximum number of arguments on a function.
+ **
+ ** - SQLITE_LIMIT_ATTACHED
+ ** - The maximum number of [ATTACH | attached databases].
+ **
+ ** - SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+ ** - The maximum length of the pattern argument to the [LIKE] or
+ ** [GLOB] operators.
+ **
+ ** - SQLITE_LIMIT_VARIABLE_NUMBER
+ ** - The maximum number of variables in an SQL statement that can
+ ** be bound.
+ **
+ */
+ //#define SQLITE_LIMIT_LENGTH 0
+ //#define SQLITE_LIMIT_SQL_LENGTH 1
+ //#define SQLITE_LIMIT_COLUMN 2
+ //#define SQLITE_LIMIT_EXPR_DEPTH 3
+ //#define SQLITE_LIMIT_COMPOUND_SELECT 4
+ //#define SQLITE_LIMIT_VDBE_OP 5
+ //#define SQLITE_LIMIT_FUNCTION_ARG 6
+ //#define SQLITE_LIMIT_ATTACHED 7
+ //#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
+ //#define SQLITE_LIMIT_VARIABLE_NUMBER 9
+ public const int SQLITE_LIMIT_LENGTH = 0;
+ public const int SQLITE_LIMIT_SQL_LENGTH = 1;
+ public const int SQLITE_LIMIT_COLUMN = 2;
+ public const int SQLITE_LIMIT_EXPR_DEPTH = 3;
+ public const int SQLITE_LIMIT_COMPOUND_SELECT = 4;
+ public const int SQLITE_LIMIT_VDBE_OP = 5;
+ public const int SQLITE_LIMIT_FUNCTION_ARG = 6;
+ public const int SQLITE_LIMIT_ATTACHED = 7;
+ public const int SQLITE_LIMIT_LIKE_PATTERN_LENGTH = 8;
+ public const int SQLITE_LIMIT_VARIABLE_NUMBER = 9;
+
+ /*
+ ** CAPI3REF: Compiling An SQL Statement {H13010}
+ ** KEYWORDS: {SQL statement compiler}
+ **
+ ** To execute an SQL query, it must first be compiled into a byte-code
+ ** program using one of these routines.
+ **
+ ** The first argument, "db", is a [database connection] obtained from a
+ ** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
+ ** [sqlite3_open16()]. The database connection must not have been closed.
+ **
+ ** The second argument, "zSql", is the statement to be compiled, encoded
+ ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
+ ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
+ ** use UTF-16.
+ **
+ ** If the nByte argument is less than zero, then zSql is read up to the
+ ** first zero terminator. If nByte is non-negative, then it is the maximum
+ ** number of bytes read from zSql. When nByte is non-negative, the
+ ** zSql string ends at either the first '\000' or '\u0000' character or
+ ** the nByte-th byte, whichever comes first. If the caller knows
+ ** that the supplied string is nul-terminated, then there is a small
+ ** performance advantage to be gained by passing an nByte parameter that
+ ** is equal to the number of bytes in the input string including
+ ** the nul-terminator bytes.
+ **
+ ** If pzTail is not NULL then *pzTail is made to point to the first byte
+ ** past the end of the first SQL statement in zSql. These routines only
+ ** compile the first statement in zSql, so *pzTail is left pointing to
+ ** what remains uncompiled.
+ **
+ ** *ppStmt is left pointing to a compiled [prepared statement] that can be
+ ** executed using [sqlite3_step()]. If there is an error, *ppStmt is set
+ ** to NULL. If the input text contains no SQL (if the input is an empty
+ ** string or a comment) then *ppStmt is set to NULL.
+ ** The calling procedure is responsible for deleting the compiled
+ ** SQL statement using [sqlite3_finalize()] after it has finished with it.
+ ** ppStmt may not be NULL.
+ **
+ ** On success, [SQLITE_OK] is returned, otherwise an [error code] is returned.
+ **
+ ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
+ ** recommended for all new programs. The two older interfaces are retained
+ ** for backwards compatibility, but their use is discouraged.
+ ** In the "v2" interfaces, the prepared statement
+ ** that is returned (the [sqlite3_stmt] object) contains a copy of the
+ ** original SQL text. This causes the [sqlite3_step()] interface to
+ ** behave a differently in two ways:
+ **
+ **
+ ** -
+ ** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
+ ** always used to do, [sqlite3_step()] will automatically recompile the SQL
+ ** statement and try to run it again. If the schema has changed in
+ ** a way that makes the statement no longer valid, [sqlite3_step()] will still
+ ** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is
+ ** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the
+ ** error go away. Note: use [sqlite3_errmsg()] to find the text
+ ** of the parsing error that results in an [SQLITE_SCHEMA] return.
+ **
+ **
+ ** -
+ ** When an error occurs, [sqlite3_step()] will return one of the detailed
+ ** [error codes] or [extended error codes]. The legacy behavior was that
+ ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
+ ** and you would have to make a second call to [sqlite3_reset()] in order
+ ** to find the underlying cause of the problem. With the "v2" prepare
+ ** interfaces, the underlying reason for the error is returned immediately.
+ **
+ **
+ **
+ ** Requirements:
+ ** [H13011] [H13012] [H13013] [H13014] [H13015] [H13016] [H13019] [H13021]
+ **
+ */
+ //SQLITE_API int sqlite3_prepare(
+ // sqlite3 *db, /* Database handle */
+ // const char *zSql, /* SQL statement, UTF-8 encoded */
+ // int nByte, /* Maximum length of zSql in bytes. */
+ // sqlite3_stmt **ppStmt, /* OUT: Statement handle */
+ // const char **pzTail /* OUT: Pointer to unused portion of zSql */
+ //);
+ //SQLITE_API int sqlite3_prepare_v2(
+ // sqlite3 *db, /* Database handle */
+ // const char *zSql, /* SQL statement, UTF-8 encoded */
+ // int nByte, /* Maximum length of zSql in bytes. */
+ // sqlite3_stmt **ppStmt, /* OUT: Statement handle */
+ // const char **pzTail /* OUT: Pointer to unused portion of zSql */
+ //);
+ //SQLITE_API int sqlite3_prepare16(
+ // sqlite3 *db, /* Database handle */
+ // const void *zSql, /* SQL statement, UTF-16 encoded */
+ // int nByte, /* Maximum length of zSql in bytes. */
+ // sqlite3_stmt **ppStmt, /* OUT: Statement handle */
+ // const void **pzTail /* OUT: Pointer to unused portion of zSql */
+ //);
+ //SQLITE_API int sqlite3_prepare16_v2(
+ // sqlite3 *db, /* Database handle */
+ // const void *zSql, /* SQL statement, UTF-16 encoded */
+ // int nByte, /* Maximum length of zSql in bytes. */
+ // sqlite3_stmt **ppStmt, /* OUT: Statement handle */
+ // const void **pzTail /* OUT: Pointer to unused portion of zSql */
+ //);
+
+ /*
+ ** CAPI3REF: Retrieving Statement SQL {H13100}
+ **
+ ** This interface can be used to retrieve a saved copy of the original
+ ** SQL text used to create a [prepared statement] if that statement was
+ ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
+ **
+ ** Requirements:
+ ** [H13101] [H13102] [H13103]
+ */
+ //SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
+
+ /*
+ ** CAPI3REF: Dynamically Typed Value Object {H15000}
+ ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
+ **
+ ** SQLite uses the sqlite3_value object to represent all values
+ ** that can be stored in a database table. SQLite uses dynamic typing
+ ** for the values it stores. Values stored in sqlite3_value objects
+ ** can be integers, floating point values, strings, BLOBs, or NULL.
+ **
+ ** An sqlite3_value object may be either "protected" or "unprotected".
+ ** Some interfaces require a protected sqlite3_value. Other interfaces
+ ** will accept either a protected or an unprotected sqlite3_value.
+ ** Every interface that accepts sqlite3_value arguments specifies
+ ** whether or not it requires a protected sqlite3_value.
+ **
+ ** The terms "protected" and "unprotected" refer to whether or not
+ ** a mutex is held. A internal mutex is held for a protected
+ ** sqlite3_value object but no mutex is held for an unprotected
+ ** sqlite3_value object. If SQLite is compiled to be single-threaded
+ ** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
+ ** or if SQLite is run in one of reduced mutex modes
+ ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
+ ** then there is no distinction between protected and unprotected
+ ** sqlite3_value objects and they can be used interchangeably. However,
+ ** for maximum code portability it is recommended that applications
+ ** still make the distinction between between protected and unprotected
+ ** sqlite3_value objects even when not strictly required.
+ **
+ ** The sqlite3_value objects that are passed as parameters into the
+ ** implementation of [application-defined SQL functions] are protected.
+ ** The sqlite3_value object returned by
+ ** [sqlite3_column_value()] is unprotected.
+ ** Unprotected sqlite3_value objects may only be used with
+ ** [sqlite3_result_value()] and [sqlite3_bind_value()].
+ ** The [sqlite3_value_blob | sqlite3_value_type()] family of
+ ** interfaces require protected sqlite3_value objects.
+ */
+ //typedef struct Mem sqlite3_value;
+
+ /*
+ ** CAPI3REF: SQL Function Context Object {H16001}
+ **
+ ** The context in which an SQL function executes is stored in an
+ ** sqlite3_context object. A pointer to an sqlite3_context object
+ ** is always first parameter to [application-defined SQL functions].
+ ** The application-defined SQL function implementation will pass this
+ ** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
+ ** [sqlite3_aggregate_context()], [sqlite3_user_data()],
+ ** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
+ ** and/or [sqlite3_set_auxdata()].
+ */
+ //typedef struct sqlite3_context sqlite3_context;
+
+ /*
+ ** CAPI3REF: Binding Values To Prepared Statements {H13500}
+ ** KEYWORDS: {host parameter} {host parameters} {host parameter name}
+ ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
+ **
+ ** In the SQL strings input to [sqlite3_prepare_v2()] and its variants,
+ ** literals may be replaced by a [parameter] in one of these forms:
+ **
+ **
+ ** - ?
+ **
- ?NNN
+ **
- :VVV
+ **
- @VVV
+ **
- $VVV
+ **
+ **
+ ** In the parameter forms shown above NNN is an integer literal,
+ ** and VVV is an alpha-numeric parameter name. The values of these
+ ** parameters (also called "host parameter names" or "SQL parameters")
+ ** can be set using the sqlite3_bind_*() routines defined here.
+ **
+ ** The first argument to the sqlite3_bind_*() routines is always
+ ** a pointer to the [sqlite3_stmt] object returned from
+ ** [sqlite3_prepare_v2()] or its variants.
+ **
+ ** The second argument is the index of the SQL parameter to be set.
+ ** The leftmost SQL parameter has an index of 1. When the same named
+ ** SQL parameter is used more than once, second and subsequent
+ ** occurrences have the same index as the first occurrence.
+ ** The index for named parameters can be looked up using the
+ ** [sqlite3_bind_parameter_index()] API if desired. The index
+ ** for "?NNN" parameters is the value of NNN.
+ ** The NNN value must be between 1 and the [sqlite3_limit()]
+ ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
+ **
+ ** The third argument is the value to bind to the parameter.
+ **
+ ** In those routines that have a fourth argument, its value is the
+ ** number of bytes in the parameter. To be clear: the value is the
+ ** number of bytes in the value, not the number of characters.
+ ** If the fourth parameter is negative, the length of the string is
+ ** the number of bytes up to the first zero terminator.
+ **
+ ** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
+ ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
+ ** string after SQLite has finished with it. If the fifth argument is
+ ** the special value [SQLITE_STATIC], then SQLite assumes that the
+ ** information is in static, unmanaged space and does not need to be freed.
+ ** If the fifth argument has the value [SQLITE_TRANSIENT], then
+ ** SQLite makes its own private copy of the data immediately, before
+ ** the sqlite3_bind_*() routine returns.
+ **
+ ** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
+ ** is filled with zeroes. A zeroblob uses a fixed amount of memory
+ ** (just an integer to hold its size) while it is being processed.
+ ** Zeroblobs are intended to serve as placeholders for BLOBs whose
+ ** content is later written using
+ ** [sqlite3_blob_open | incremental BLOB I/O] routines.
+ ** A negative value for the zeroblob results in a zero-length BLOB.
+ **
+ ** The sqlite3_bind_*() routines must be called after
+ ** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and
+ ** before [sqlite3_step()].
+ ** Bindings are not cleared by the [sqlite3_reset()] routine.
+ ** Unbound parameters are interpreted as NULL.
+ **
+ ** These routines return [SQLITE_OK] on success or an error code if
+ ** anything goes wrong. [SQLITE_RANGE] is returned if the parameter
+ ** index is out of range. [SQLITE_NOMEM] is returned if malloc() fails.
+ ** [SQLITE_MISUSE] might be returned if these routines are called on a
+ ** virtual machine that is the wrong state or which has already been finalized.
+ ** Detection of misuse is unreliable. Applications should not depend
+ ** on SQLITE_MISUSE returns. SQLITE_MISUSE is intended to indicate a
+ ** a logic error in the application. Future versions of SQLite might
+ ** panic rather than return SQLITE_MISUSE.
+ **
+ ** See also: [sqlite3_bind_parameter_count()],
+ ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
+ **
+ ** Requirements:
+ ** [H13506] [H13509] [H13512] [H13515] [H13518] [H13521] [H13524] [H13527]
+ ** [H13530] [H13533] [H13536] [H13539] [H13542] [H13545] [H13548] [H13551]
+ **
+ */
+ //SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
+ //SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
+ //SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
+ //SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
+ //SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
+ //SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
+ //SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
+ //SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
+ //SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
+
+ /*
+ ** CAPI3REF: Number Of SQL Parameters {H13600}
+ **
+ ** This routine can be used to find the number of [SQL parameters]
+ ** in a [prepared statement]. SQL parameters are tokens of the
+ ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
+ ** placeholders for values that are [sqlite3_bind_blob | bound]
+ ** to the parameters at a later time.
+ **
+ ** This routine actually returns the index of the largest (rightmost)
+ ** parameter. For all forms except ?NNN, this will correspond to the
+ ** number of unique parameters. If parameters of the ?NNN are used,
+ ** there may be gaps in the list.
+ **
+ ** See also: [sqlite3_bind_blob|sqlite3_bind()],
+ ** [sqlite3_bind_parameter_name()], and
+ ** [sqlite3_bind_parameter_index()].
+ **
+ ** Requirements:
+ ** [H13601]
+ */
+ //SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
+
+ /*
+ ** CAPI3REF: Name Of A Host Parameter {H13620}
+ **
+ ** This routine returns a pointer to the name of the n-th
+ ** [SQL parameter] in a [prepared statement].
+ ** SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
+ ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
+ ** respectively.
+ ** In other words, the initial ":" or "$" or "@" or "?"
+ ** is included as part of the name.
+ ** Parameters of the form "?" without a following integer have no name
+ ** and are also referred to as "anonymous parameters".
+ **
+ ** The first host parameter has an index of 1, not 0.
+ **
+ ** If the value n is out of range or if the n-th parameter is
+ ** nameless, then NULL is returned. The returned string is
+ ** always in UTF-8 encoding even if the named parameter was
+ ** originally specified as UTF-16 in [sqlite3_prepare16()] or
+ ** [sqlite3_prepare16_v2()].
+ **
+ ** See also: [sqlite3_bind_blob|sqlite3_bind()],
+ ** [sqlite3_bind_parameter_count()], and
+ ** [sqlite3_bind_parameter_index()].
+ **
+ ** Requirements:
+ ** [H13621]
+ */
+ //SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
+
+ /*
+ ** CAPI3REF: Index Of A Parameter With A Given Name {H13640}
+ **
+ ** Return the index of an SQL parameter given its name. The
+ ** index value returned is suitable for use as the second
+ ** parameter to [sqlite3_bind_blob|sqlite3_bind()]. A zero
+ ** is returned if no matching parameter is found. The parameter
+ ** name must be given in UTF-8 even if the original statement
+ ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
+ **
+ ** See also: [sqlite3_bind_blob|sqlite3_bind()],
+ ** [sqlite3_bind_parameter_count()], and
+ ** [sqlite3_bind_parameter_index()].
+ **
+ ** Requirements:
+ ** [H13641]
+ */
+ //SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
+
+ /*
+ ** CAPI3REF: Reset All Bindings On A Prepared Statement {H13660}
+ **
+ ** Contrary to the intuition of many, [sqlite3_reset()] does not reset
+ ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
+ ** Use this routine to reset all host parameters to NULL.
+ **
+ ** Requirements:
+ ** [H13661]
+ */
+ //SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
+
+ /*
+ ** CAPI3REF: Number Of Columns In A Result Set {H13710}
+ **
+ ** Return the number of columns in the result set returned by the
+ ** [prepared statement]. This routine returns 0 if pStmt is an SQL
+ ** statement that does not return data (for example an [UPDATE]).
+ **
+ ** Requirements:
+ ** [H13711]
+ */
+ //SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
+
+ /*
+ ** CAPI3REF: Column Names In A Result Set {H13720}
+ **
+ ** These routines return the name assigned to a particular column
+ ** in the result set of a [SELECT] statement. The sqlite3_column_name()
+ ** interface returns a pointer to a zero-terminated UTF-8 string
+ ** and sqlite3_column_name16() returns a pointer to a zero-terminated
+ ** UTF-16 string. The first parameter is the [prepared statement]
+ ** that implements the [SELECT] statement. The second parameter is the
+ ** column number. The leftmost column is number 0.
+ **
+ ** The returned string pointer is valid until either the [prepared statement]
+ ** is destroyed by [sqlite3_finalize()] or until the next call to
+ ** sqlite3_column_name() or sqlite3_column_name16() on the same column.
+ **
+ ** If sqlite3_malloc() fails during the processing of either routine
+ ** (for example during a conversion from UTF-8 to UTF-16) then a
+ ** NULL pointer is returned.
+ **
+ ** The name of a result column is the value of the "AS" clause for
+ ** that column, if there is an AS clause. If there is no AS clause
+ ** then the name of the column is unspecified and may change from
+ ** one release of SQLite to the next.
+ **
+ ** Requirements:
+ ** [H13721] [H13723] [H13724] [H13725] [H13726] [H13727]
+ */
+ //SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
+ //SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
+
+ /*
+ ** CAPI3REF: Source Of Data In A Query Result {H13740}
+ **
+ ** These routines provide a means to determine what column of what
+ ** table in which database a result of a [SELECT] statement comes from.
+ ** The name of the database or table or column can be returned as
+ ** either a UTF-8 or UTF-16 string. The _database_ routines return
+ ** the database name, the _table_ routines return the table name, and
+ ** the origin_ routines return the column name.
+ ** The returned string is valid until the [prepared statement] is destroyed
+ ** using [sqlite3_finalize()] or until the same information is requested
+ ** again in a different encoding.
+ **
+ ** The names returned are the original un-aliased names of the
+ ** database, table, and column.
+ **
+ ** The first argument to the following calls is a [prepared statement].
+ ** These functions return information about the Nth column returned by
+ ** the statement, where N is the second function argument.
+ **
+ ** If the Nth column returned by the statement is an expression or
+ ** subquery and is not a column value, then all of these functions return
+ ** NULL. These routine might also return NULL if a memory allocation error
+ ** occurs. Otherwise, they return the name of the attached database, table
+ ** and column that query result column was extracted from.
+ **
+ ** As with all other SQLite APIs, those postfixed with "16" return
+ ** UTF-16 encoded strings, the other functions return UTF-8. {END}
+ **
+ ** These APIs are only available if the library was compiled with the
+ ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
+ **
+ ** {A13751}
+ ** If two or more threads call one or more of these routines against the same
+ ** prepared statement and column at the same time then the results are
+ ** undefined.
+ **
+ ** Requirements:
+ ** [H13741] [H13742] [H13743] [H13744] [H13745] [H13746] [H13748]
+ **
+ ** If two or more threads call one or more
+ ** [sqlite3_column_database_name | column metadata interfaces]
+ ** for the same [prepared statement] and result column
+ ** at the same time then the results are undefined.
+ */
+ //SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
+ //SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
+ //SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
+ //SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
+ //SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
+ //SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
+
+ /*
+ ** CAPI3REF: Declared Datatype Of A Query Result {H13760}
+ **
+ ** The first parameter is a [prepared statement].
+ ** If this statement is a [SELECT] statement and the Nth column of the
+ ** returned result set of that [SELECT] is a table column (not an
+ ** expression or subquery) then the declared type of the table
+ ** column is returned. If the Nth column of the result set is an
+ ** expression or subquery, then a NULL pointer is returned.
+ ** The returned string is always UTF-8 encoded. {END}
+ **
+ ** For example, given the database schema:
+ **
+ ** CREATE TABLE t1(c1 VARIANT);
+ **
+ ** and the following statement to be compiled:
+ **
+ ** SELECT c1 + 1, c1 FROM t1;
+ **
+ ** this routine would return the string "VARIANT" for the second result
+ ** column (i==1), and a NULL pointer for the first result column (i==0).
+ **
+ ** SQLite uses dynamic run-time typing. So just because a column
+ ** is declared to contain a particular type does not mean that the
+ ** data stored in that column is of the declared type. SQLite is
+ ** strongly typed, but the typing is dynamic not static. Type
+ ** is associated with individual values, not with the containers
+ ** used to hold those values.
+ **
+ ** Requirements:
+ ** [H13761] [H13762] [H13763]
+ */
+ //SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
+ //SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+
+ /*
+ ** CAPI3REF: Evaluate An SQL Statement {H13200}
+ **
+ ** After a [prepared statement] has been prepared using either
+ ** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
+ ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
+ ** must be called one or more times to evaluate the statement.
+ **
+ ** The details of the behavior of the sqlite3_step() interface depend
+ ** on whether the statement was prepared using the newer "v2" interface
+ ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
+ ** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the
+ ** new "v2" interface is recommended for new applications but the legacy
+ ** interface will continue to be supported.
+ **
+ ** In the legacy interface, the return value will be either [SQLITE_BUSY],
+ ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
+ ** With the "v2" interface, any of the other [result codes] or
+ ** [extended result codes] might be returned as well.
+ **
+ ** [SQLITE_BUSY] means that the database engine was unable to acquire the
+ ** database locks it needs to do its job. If the statement is a [COMMIT]
+ ** or occurs outside of an explicit transaction, then you can retry the
+ ** statement. If the statement is not a [COMMIT] and occurs within a
+ ** explicit transaction then you should rollback the transaction before
+ ** continuing.
+ **
+ ** [SQLITE_DONE] means that the statement has finished executing
+ ** successfully. sqlite3_step() should not be called again on this virtual
+ ** machine without first calling [sqlite3_reset()] to reset the virtual
+ ** machine back to its initial state.
+ **
+ ** If the SQL statement being executed returns any data, then [SQLITE_ROW]
+ ** is returned each time a new row of data is ready for processing by the
+ ** caller. The values may be accessed using the [column access functions].
+ ** sqlite3_step() is called again to retrieve the next row of data.
+ **
+ ** [SQLITE_ERROR] means that a run-time error (such as a constraint
+ ** violation) has occurred. sqlite3_step() should not be called again on
+ ** the VM. More information may be found by calling [sqlite3_errmsg()].
+ ** With the legacy interface, a more specific error code (for example,
+ ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
+ ** can be obtained by calling [sqlite3_reset()] on the
+ ** [prepared statement]. In the "v2" interface,
+ ** the more specific error code is returned directly by sqlite3_step().
+ **
+ ** [SQLITE_MISUSE] means that the this routine was called inappropriately.
+ ** Perhaps it was called on a [prepared statement] that has
+ ** already been [sqlite3_finalize | finalized] or on one that had
+ ** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could
+ ** be the case that the same database connection is being used by two or
+ ** more threads at the same moment in time.
+ **
+ ** Goofy Interface Alert: In the legacy interface, the sqlite3_step()
+ ** API always returns a generic error code, [SQLITE_ERROR], following any
+ ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
+ ** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
+ ** specific [error codes] that better describes the error.
+ ** We admit that this is a goofy design. The problem has been fixed
+ ** with the "v2" interface. If you prepare all of your SQL statements
+ ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
+ ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
+ ** then the more specific [error codes] are returned directly
+ ** by sqlite3_step(). The use of the "v2" interface is recommended.
+ **
+ ** Requirements:
+ ** [H13202] [H15304] [H15306] [H15308] [H15310]
+ */
+ //SQLITE_API int sqlite3_step(sqlite3_stmt*);
+
+ /*
+ ** CAPI3REF: Number of columns in a result set {H13770}
+ **
+ ** Returns the number of values in the current row of the result set.
+ **
+ ** Requirements:
+ ** [H13771] [H13772]
+ */
+ //SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
+
+ /*
+ ** CAPI3REF: Fundamental Datatypes {H10265}
+ ** KEYWORDS: SQLITE_TEXT
+ **
+ ** {H10266} Every value in SQLite has one of five fundamental datatypes:
+ **
+ **
+ ** - 64-bit signed integer
+ **
- 64-bit IEEE floating point number
+ **
- string
+ **
- BLOB
+ **
- NULL
+ **
{END}
+ **
+ ** These constants are codes for each of those types.
+ **
+ ** Note that the SQLITE_TEXT constant was also used in SQLite version 2
+ ** for a completely different meaning. Software that links against both
+ ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
+ ** SQLITE_TEXT.
+ */
+ //#define SQLITE_INTEGER 1
+ //#define SQLITE_FLOAT 2
+ //#define SQLITE_BLOB 4
+ //#define SQLITE_NULL 5
+ //#ifdef SQLITE_TEXT
+ //# undef SQLITE_TEXT
+ //#else
+ //# define SQLITE_TEXT 3
+ //#endif
+ //#define SQLITE3_TEXT 3
+ public const u8 SQLITE_INTEGER = 1;
+ public const u8 SQLITE_FLOAT = 2;
+ public const u8 SQLITE_BLOB = 4;
+ public const u8 SQLITE_NULL = 5;
+ public const u8 SQLITE_TEXT = 3;
+ public const u8 SQLITE3_TEXT = 3;
+
+ /*
+ ** CAPI3REF: Result Values From A Query {H13800}
+ ** KEYWORDS: {column access functions}
+ **
+ ** These routines form the "result set query" interface.
+ **
+ ** These routines return information about a single column of the current
+ ** result row of a query. In every case the first argument is a pointer
+ ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
+ ** that was returned from [sqlite3_prepare_v2()] or one of its variants)
+ ** and the second argument is the index of the column for which information
+ ** should be returned. The leftmost column of the result set has the index 0.
+ **
+ ** If the SQL statement does not currently point to a valid row, or if the
+ ** column index is out of range, the result is undefined.
+ ** These routines may only be called when the most recent call to
+ ** [sqlite3_step()] has returned [SQLITE_ROW] and neither
+ ** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
+ ** If any of these routines are called after [sqlite3_reset()] or
+ ** [sqlite3_finalize()] or after [sqlite3_step()] has returned
+ ** something other than [SQLITE_ROW], the results are undefined.
+ ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
+ ** are called from a different thread while any of these routines
+ ** are pending, then the results are undefined.
+ **
+ ** The sqlite3_column_type() routine returns the
+ ** [SQLITE_INTEGER | datatype code] for the initial data type
+ ** of the result column. The returned value is one of [SQLITE_INTEGER],
+ ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value
+ ** returned by sqlite3_column_type() is only meaningful if no type
+ ** conversions have occurred as described below. After a type conversion,
+ ** the value returned by sqlite3_column_type() is undefined. Future
+ ** versions of SQLite may change the behavior of sqlite3_column_type()
+ ** following a type conversion.
+ **
+ ** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
+ ** routine returns the number of bytes in that BLOB or string.
+ ** If the result is a UTF-16 string, then sqlite3_column_bytes() converts
+ ** the string to UTF-8 and then returns the number of bytes.
+ ** If the result is a numeric value then sqlite3_column_bytes() uses
+ ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
+ ** the number of bytes in that string.
+ ** The value returned does not include the zero terminator at the end
+ ** of the string. For clarity: the value returned is the number of
+ ** bytes in the string, not the number of characters.
+ **
+ ** Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
+ ** even empty strings, are always zero terminated. The return
+ ** value from sqlite3_column_blob() for a zero-length BLOB is an arbitrary
+ ** pointer, possibly even a NULL pointer.
+ **
+ ** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
+ ** but leaves the result in UTF-16 in native byte order instead of UTF-8.
+ ** The zero terminator is not included in this count.
+ **
+ ** The object returned by [sqlite3_column_value()] is an
+ ** [unprotected sqlite3_value] object. An unprotected sqlite3_value object
+ ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()].
+ ** If the [unprotected sqlite3_value] object returned by
+ ** [sqlite3_column_value()] is used in any other way, including calls
+ ** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
+ ** or [sqlite3_value_bytes()], then the behavior is undefined.
+ **
+ ** These routines attempt to convert the value where appropriate. For
+ ** example, if the internal representation is FLOAT and a text result
+ ** is requested, [sqlite3_snprintf()] is used internally to perform the
+ ** conversion automatically. The following table details the conversions
+ ** that are applied:
+ **
+ **
+ **
+ ** Internal
Type | Requested
Type | Conversion
+ **
+ ** |
|---|
| NULL | INTEGER | Result is 0
+ ** |
| NULL | FLOAT | Result is 0.0
+ ** |
| NULL | TEXT | Result is NULL pointer
+ ** |
| NULL | BLOB | Result is NULL pointer
+ ** |
| INTEGER | FLOAT | Convert from integer to float
+ ** |
| INTEGER | TEXT | ASCII rendering of the integer
+ ** |
| INTEGER | BLOB | Same as INTEGER->TEXT
+ ** |
| FLOAT | INTEGER | Convert from float to integer
+ ** |
| FLOAT | TEXT | ASCII rendering of the float
+ ** |
| FLOAT | BLOB | Same as FLOAT->TEXT
+ ** |
| TEXT | INTEGER | Use atoi()
+ ** |
| TEXT | FLOAT | Use atof()
+ ** |
| TEXT | BLOB | No change
+ ** |
| BLOB | INTEGER | Convert to TEXT then use atoi()
+ ** |
| BLOB | FLOAT | Convert to TEXT then use atof()
+ ** |
| BLOB | TEXT | Add a zero terminator if needed
+ ** |
+ **
+ **
+ ** The table above makes reference to standard C library functions atoi()
+ ** and atof(). SQLite does not really use these functions. It has its
+ ** own equivalent internal routines. The atoi() and atof() names are
+ ** used in the table for brevity and because they are familiar to most
+ ** C programmers.
+ **
+ ** Note that when type conversions occur, pointers returned by prior
+ ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
+ ** sqlite3_column_text16() may be invalidated.
+ ** Type conversions and pointer invalidations might occur
+ ** in the following cases:
+ **
+ **
+ ** - The initial content is a BLOB and sqlite3_column_text() or
+ ** sqlite3_column_text16() is called. A zero-terminator might
+ ** need to be added to the string.
+ ** - The initial content is UTF-8 text and sqlite3_column_bytes16() or
+ ** sqlite3_column_text16() is called. The content must be converted
+ ** to UTF-16.
+ ** - The initial content is UTF-16 text and sqlite3_column_bytes() or
+ ** sqlite3_column_text() is called. The content must be converted
+ ** to UTF-8.
+ **
+ **
+ ** Conversions between UTF-16be and UTF-16le are always done in place and do
+ ** not invalidate a prior pointer, though of course the content of the buffer
+ ** that the prior pointer points to will have been modified. Other kinds
+ ** of conversion are done in place when it is possible, but sometimes they
+ ** are not possible and in those cases prior pointers are invalidated.
+ **
+ ** The safest and easiest to remember policy is to invoke these routines
+ ** in one of the following ways:
+ **
+ **
+ ** - sqlite3_column_text() followed by sqlite3_column_bytes()
+ ** - sqlite3_column_blob() followed by sqlite3_column_bytes()
+ ** - sqlite3_column_text16() followed by sqlite3_column_bytes16()
+ **
+ **
+ ** In other words, you should call sqlite3_column_text(),
+ ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
+ ** into the desired format, then invoke sqlite3_column_bytes() or
+ ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
+ ** to sqlite3_column_text() or sqlite3_column_blob() with calls to
+ ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
+ ** with calls to sqlite3_column_bytes().
+ **
+ ** The pointers returned are valid until a type conversion occurs as
+ ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
+ ** [sqlite3_finalize()] is called. The memory space used to hold strings
+ ** and BLOBs is freed automatically. Do not pass the pointers returned
+ ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
+ ** [sqlite3_free()].
+ **
+ ** If a memory allocation error occurs during the evaluation of any
+ ** of these routines, a default value is returned. The default value
+ ** is either the integer 0, the floating point number 0.0, or a NULL
+ ** pointer. Subsequent calls to [sqlite3_errcode()] will return
+ ** [SQLITE_NOMEM].
+ **
+ ** Requirements:
+ ** [H13803] [H13806] [H13809] [H13812] [H13815] [H13818] [H13821] [H13824]
+ ** [H13827] [H13830]
+ */
+ //SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
+ //SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
+ //SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
+ //SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
+ //SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
+ //SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
+ //SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
+ //SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
+ //SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
+ //SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
+
+ /*
+ ** CAPI3REF: Destroy A Prepared Statement Object {H13300}
+ **
+ ** The sqlite3_finalize() function is called to delete a [prepared statement].
+ ** If the statement was executed successfully or not executed at all, then
+ ** SQLITE_OK is returned. If execution of the statement failed then an
+ ** [error code] or [extended error code] is returned.
+ **
+ ** This routine can be called at any point during the execution of the
+ ** [prepared statement]. If the virtual machine has not
+ ** completed execution when this routine is called, that is like
+ ** encountering an error or an [sqlite3_interrupt | interrupt].
+ ** Incomplete updates may be rolled back and transactions canceled,
+ ** depending on the circumstances, and the
+ ** [error code] returned will be [SQLITE_ABORT].
+ **
+ ** Requirements:
+ ** [H11302] [H11304]
+ */
+ //SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
+
+ /*
+ ** CAPI3REF: Reset A Prepared Statement Object {H13330}
+ **
+ ** The sqlite3_reset() function is called to reset a [prepared statement]
+ ** object back to its initial state, ready to be re-executed.
+ ** Any SQL statement variables that had values bound to them using
+ ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
+ ** Use [sqlite3_clear_bindings()] to reset the bindings.
+ **
+ ** {H11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S
+ ** back to the beginning of its program.
+ **
+ ** {H11334} If the most recent call to [sqlite3_step(S)] for the
+ ** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
+ ** or if [sqlite3_step(S)] has never before been called on S,
+ ** then [sqlite3_reset(S)] returns [SQLITE_OK].
+ **
+ ** {H11336} If the most recent call to [sqlite3_step(S)] for the
+ ** [prepared statement] S indicated an error, then
+ ** [sqlite3_reset(S)] returns an appropriate [error code].
+ **
+ ** {H11338} The [sqlite3_reset(S)] interface does not change the values
+ ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
+ */
+ //SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
+
+ /*
+ ** CAPI3REF: Create Or Redefine SQL Functions {H16100}
+ ** KEYWORDS: {function creation routines}
+ ** KEYWORDS: {application-defined SQL function}
+ ** KEYWORDS: {application-defined SQL functions}
+ **
+ ** These two functions (collectively known as "function creation routines")
+ ** are used to add SQL functions or aggregates or to redefine the behavior
+ ** of existing SQL functions or aggregates. The only difference between the
+ ** two is that the second parameter, the name of the (scalar) function or
+ ** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16
+ ** for sqlite3_create_function16().
+ **
+ ** The first parameter is the [database connection] to which the SQL
+ ** function is to be added. If a single program uses more than one database
+ ** connection internally, then SQL functions must be added individually to
+ ** each database connection.
+ **
+ ** The second parameter is the name of the SQL function to be created or
+ ** redefined. The length of the name is limited to 255 bytes, exclusive of
+ ** the zero-terminator. Note that the name length limit is in bytes, not
+ ** characters. Any attempt to create a function with a longer name
+ ** will result in [SQLITE_ERROR] being returned.
+ **
+ ** The third parameter (nArg)
+ ** is the number of arguments that the SQL function or
+ ** aggregate takes. If this parameter is -1, then the SQL function or
+ ** aggregate may take any number of arguments between 0 and the limit
+ ** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third
+ ** parameter is less than -1 or greater than 127 then the behavior is
+ ** undefined.
+ **
+ ** The fourth parameter, eTextRep, specifies what
+ ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
+ ** its parameters. Any SQL function implementation should be able to work
+ ** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be
+ ** more efficient with one encoding than another. It is allowed to
+ ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
+ ** times with the same function but with different values of eTextRep.
+ ** When multiple implementations of the same function are available, SQLite
+ ** will pick the one that involves the least amount of data conversion.
+ ** If there is only a single implementation which does not care what text
+ ** encoding is used, then the fourth argument should be [SQLITE_ANY].
+ **
+ ** The fifth parameter is an arbitrary pointer. The implementation of the
+ ** function can gain access to this pointer using [sqlite3_user_data()].
+ **
+ ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are
+ ** pointers to C-language functions that implement the SQL function or
+ ** aggregate. A scalar SQL function requires an implementation of the xFunc
+ ** callback only, NULL pointers should be passed as the xStep and xFinal
+ ** parameters. An aggregate SQL function requires an implementation of xStep
+ ** and xFinal and NULL should be passed for xFunc. To delete an existing
+ ** SQL function or aggregate, pass NULL for all three function callbacks.
+ **
+ ** It is permitted to register multiple implementations of the same
+ ** functions with the same name but with either differing numbers of
+ ** arguments or differing preferred text encodings. SQLite will use
+ ** the implementation most closely matches the way in which the
+ ** SQL function is used. A function implementation with a non-negative
+ ** nArg parameter is a better match than a function implementation with
+ ** a negative nArg. A function where the preferred text encoding
+ ** matches the database encoding is a better
+ ** match than a function where the encoding is different.
+ ** A function where the encoding difference is between UTF16le and UTF16be
+ ** is a closer match than a function where the encoding difference is
+ ** between UTF8 and UTF16.
+ **
+ ** Built-in functions may be overloaded by new application-defined functions.
+ ** The first application-defined function with a given name overrides all
+ ** built-in functions in the same [database connection] with the same name.
+ ** Subsequent application-defined functions of the same name only override
+ ** prior application-defined functions that are an exact match for the
+ ** number of parameters and preferred encoding.
+ **
+ ** An application-defined function is permitted to call other
+ ** SQLite interfaces. However, such calls must not
+ ** close the database connection nor finalize or reset the prepared
+ ** statement in which the function is running.
+ **
+ ** Requirements:
+ ** [H16103] [H16106] [H16109] [H16112] [H16118] [H16121] [H16127]
+ ** [H16130] [H16133] [H16136] [H16139] [H16142]
+ */
+ //SQLITE_API int sqlite3_create_function(
+ // sqlite3 *db,
+ // const char *zFunctionName,
+ // int nArg,
+ // int eTextRep,
+ // void *pApp,
+ // void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+ // void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+ // void (*xFinal)(sqlite3_context*)
+ //);
+ //SQLITE_API int sqlite3_create_function16(
+ // sqlite3 *db,
+ // const void *zFunctionName,
+ // int nArg,
+ // int eTextRep,
+ // void *pApp,
+ // void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+ // void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+ // void (*xFinal)(sqlite3_context*)
+ //);
+
+ /*
+ ** CAPI3REF: Text Encodings {H10267}
+ **
+ ** These constant define integer codes that represent the various
+ ** text encodings supported by SQLite.
+ */
+ //#define SQLITE_UTF8 1
+ //#define SQLITE_UTF16LE 2
+ //#define SQLITE_UTF16BE 3
+ //#define SQLITE_UTF16 4 /* Use native byte order */
+ //#define SQLITE_ANY 5 /* sqlite3_create_function only */
+ //#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */
+ public const u8 SQLITE_UTF8 = 1;
+ public const u8 SQLITE_UTF16LE = 2;
+ public const u8 SQLITE_UTF16BE = 3;
+ public const u8 SQLITE_UTF16 = 4;
+ public const u8 SQLITE_ANY = 5;
+ public const u8 SQLITE_UTF16_ALIGNED = 8;
+
+ /*
+ ** CAPI3REF: Deprecated Functions
+ ** DEPRECATED
+ **
+ ** These functions are [deprecated]. In order to maintain
+ ** backwards compatibility with older code, these functions continue
+ ** to be supported. However, new applications should avoid
+ ** the use of these functions. To help encourage people to avoid
+ ** using these functions, we are not going to tell you what they do.
+ */
+#if !SQLITE_OMIT_DEPRECATED
+//SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
+//SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
+//SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
+//SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
+//SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
+//SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
+#endif
+
+ /*
+** CAPI3REF: Obtaining SQL Function Parameter Values {H15100}
+**
+** The C-language implementation of SQL functions and aggregates uses
+** this set of interface routines to access the parameter values on
+** the function or aggregate.
+**
+** The xFunc (for scalar functions) or xStep (for aggregates) parameters
+** to [sqlite3_create_function()] and [sqlite3_create_function16()]
+** define callbacks that implement the SQL functions and aggregates.
+** The 4th parameter to these callbacks is an array of pointers to
+** [protected sqlite3_value] objects. There is one [sqlite3_value] object for
+** each parameter to the SQL function. These routines are used to
+** extract values from the [sqlite3_value] objects.
+**
+** These routines work only with [protected sqlite3_value] objects.
+** Any attempt to use these routines on an [unprotected sqlite3_value]
+** object results in undefined behavior.
+**
+** These routines work just like the corresponding [column access functions]
+** except that these routines take a single [protected sqlite3_value] object
+** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
+**
+** The sqlite3_value_text16() interface extracts a UTF-16 string
+** in the native byte-order of the host machine. The
+** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
+** extract UTF-16 strings as big-endian and little-endian respectively.
+**
+** The sqlite3_value_numeric_type() interface attempts to apply
+** numeric affinity to the value. This means that an attempt is
+** made to convert the value to an integer or floating point. If
+** such a conversion is possible without loss of information (in other
+** words, if the value is a string that looks like a number)
+** then the conversion is performed. Otherwise no conversion occurs.
+** The [SQLITE_INTEGER | datatype] after conversion is returned.
+**
+** Please pay particular attention to the fact that the pointer returned
+** from [sqlite3_value_blob()], [sqlite3_value_text()], or
+** [sqlite3_value_text16()] can be invalidated by a subsequent call to
+** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
+** or [sqlite3_value_text16()].
+**
+** These routines must be called from the same thread as
+** the SQL function that supplied the [sqlite3_value*] parameters.
+**
+** Requirements:
+** [H15103] [H15106] [H15109] [H15112] [H15115] [H15118] [H15121] [H15124]
+** [H15127] [H15130] [H15133] [H15136]
+*/
+ //SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
+ //SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
+ //SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
+ //SQLITE_API double sqlite3_value_double(sqlite3_value*);
+ //SQLITE_API int sqlite3_value_int(sqlite3_value*);
+ //SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
+ //SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
+ //SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
+ //SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
+ //SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
+ //SQLITE_API int sqlite3_value_type(sqlite3_value*);
+ //SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
+
+ /*
+ ** CAPI3REF: Obtain Aggregate Function Context {H16210}
+ **
+ ** The implementation of aggregate SQL functions use this routine to allocate
+ ** a structure for storing their state.
+ **
+ ** The first time the sqlite3_aggregate_context() routine is called for a
+ ** particular aggregate, SQLite allocates nBytes of memory, zeroes out that
+ ** memory, and returns a pointer to it. On second and subsequent calls to
+ ** sqlite3_aggregate_context() for the same aggregate function index,
+ ** the same buffer is returned. The implementation of the aggregate can use
+ ** the returned buffer to accumulate data.
+ **
+ ** SQLite automatically frees the allocated buffer when the aggregate
+ ** query concludes.
+ **
+ ** The first parameter should be a copy of the
+ ** [sqlite3_context | SQL function context] that is the first parameter
+ ** to the callback routine that implements the aggregate function.
+ **
+ ** This routine must be called from the same thread in which
+ ** the aggregate SQL function is running.
+ **
+ ** Requirements:
+ ** [H16211] [H16213] [H16215] [H16217]
+ */
+ //SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
+
+ /*
+ ** CAPI3REF: User Data For Functions {H16240}
+ **
+ ** The sqlite3_user_data() interface returns a copy of
+ ** the pointer that was the pUserData parameter (the 5th parameter)
+ ** of the [sqlite3_create_function()]
+ ** and [sqlite3_create_function16()] routines that originally
+ ** registered the application defined function. {END}
+ **
+ ** This routine must be called from the same thread in which
+ ** the application-defined function is running.
+ **
+ ** Requirements:
+ ** [H16243]
+ */
+ //SQLITE_API void *sqlite3_user_data(sqlite3_context*);
+
+ /*
+ ** CAPI3REF: Database Connection For Functions {H16250}
+ **
+ ** The sqlite3_context_db_handle() interface returns a copy of
+ ** the pointer to the [database connection] (the 1st parameter)
+ ** of the [sqlite3_create_function()]
+ ** and [sqlite3_create_function16()] routines that originally
+ ** registered the application defined function.
+ **
+ ** Requirements:
+ ** [H16253]
+ */
+ //SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
+
+ /*
+ ** CAPI3REF: Function Auxiliary Data {H16270}
+ **
+ ** The following two functions may be used by scalar SQL functions to
+ ** associate metadata with argument values. If the same value is passed to
+ ** multiple invocations of the same SQL function during query execution, under
+ ** some circumstances the associated metadata may be preserved. This may
+ ** be used, for example, to add a regular-expression matching scalar
+ ** function. The compiled version of the regular expression is stored as
+ ** metadata associated with the SQL value passed as the regular expression
+ ** pattern. The compiled regular expression can be reused on multiple
+ ** invocations of the same function so that the original pattern string
+ ** does not need to be recompiled on each invocation.
+ **
+ ** The sqlite3_get_auxdata() interface returns a pointer to the metadata
+ ** associated by the sqlite3_set_auxdata() function with the Nth argument
+ ** value to the application-defined function. If no metadata has been ever
+ ** been set for the Nth argument of the function, or if the corresponding
+ ** function parameter has changed since the meta-data was set,
+ ** then sqlite3_get_auxdata() returns a NULL pointer.
+ **
+ ** The sqlite3_set_auxdata() interface saves the metadata
+ ** pointed to by its 3rd parameter as the metadata for the N-th
+ ** argument of the application-defined function. Subsequent
+ ** calls to sqlite3_get_auxdata() might return this data, if it has
+ ** not been destroyed.
+ ** If it is not NULL, SQLite will invoke the destructor
+ ** function given by the 4th parameter to sqlite3_set_auxdata() on
+ ** the metadata when the corresponding function parameter changes
+ ** or when the SQL statement completes, whichever comes first.
+ **
+ ** SQLite is free to call the destructor and drop metadata on any
+ ** parameter of any function at any time. The only guarantee is that
+ ** the destructor will be called before the metadata is dropped.
+ **
+ ** In practice, metadata is preserved between function calls for
+ ** expressions that are constant at compile time. This includes literal
+ ** values and SQL variables.
+ **
+ ** These routines must be called from the same thread in which
+ ** the SQL function is running.
+ **
+ ** Requirements:
+ ** [H16272] [H16274] [H16276] [H16277] [H16278] [H16279]
+ */
+ //SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
+ //SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
+
+
+ /*
+ ** CAPI3REF: Constants Defining Special Destructor Behavior {H10280}
+ **
+ ** These are special values for the destructor that is passed in as the
+ ** final argument to routines like [sqlite3_result_blob()]. If the destructor
+ ** argument is SQLITE_STATIC, it means that the content pointer is constant
+ ** and will never change. It does not need to be destroyed. The
+ ** SQLITE_TRANSIENT value means that the content will likely change in
+ ** the near future and that SQLite should make its own private copy of
+ ** the content before returning.
+ **
+ ** The typedef is necessary to work around problems in certain
+ ** C++ compilers. See ticket #2191.
+ */
+ //typedef void (*sqlite3_destructor_type)(void*);
+ //#define SQLITE_STATIC ((sqlite3_destructor_type)0)
+ //#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
+ public static dxDel SQLITE_STATIC;
+ public static dxDel SQLITE_TRANSIENT;
+
+ /*
+ ** CAPI3REF: Setting The Result Of An SQL Function {H16400}
+ **
+ ** These routines are used by the xFunc or xFinal callbacks that
+ ** implement SQL functions and aggregates. See
+ ** [sqlite3_create_function()] and [sqlite3_create_function16()]
+ ** for additional information.
+ **
+ ** These functions work very much like the [parameter binding] family of
+ ** functions used to bind values to host parameters in prepared statements.
+ ** Refer to the [SQL parameter] documentation for additional information.
+ **
+ ** The sqlite3_result_blob() interface sets the result from
+ ** an application-defined function to be the BLOB whose content is pointed
+ ** to by the second parameter and which is N bytes long where N is the
+ ** third parameter.
+ **
+ ** The sqlite3_result_zeroblob() interfaces set the result of
+ ** the application-defined function to be a BLOB containing all zero
+ ** bytes and N bytes in size, where N is the value of the 2nd parameter.
+ **
+ ** The sqlite3_result_double() interface sets the result from
+ ** an application-defined function to be a floating point value specified
+ ** by its 2nd argument.
+ **
+ ** The sqlite3_result_error() and sqlite3_result_error16() functions
+ ** cause the implemented SQL function to throw an exception.
+ ** SQLite uses the string pointed to by the
+ ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
+ ** as the text of an error message. SQLite interprets the error
+ ** message string from sqlite3_result_error() as UTF-8. SQLite
+ ** interprets the string from sqlite3_result_error16() as UTF-16 in native
+ ** byte order. If the third parameter to sqlite3_result_error()
+ ** or sqlite3_result_error16() is negative then SQLite takes as the error
+ ** message all text up through the first zero character.
+ ** If the third parameter to sqlite3_result_error() or
+ ** sqlite3_result_error16() is non-negative then SQLite takes that many
+ ** bytes (not characters) from the 2nd parameter as the error message.
+ ** The sqlite3_result_error() and sqlite3_result_error16()
+ ** routines make a private copy of the error message text before
+ ** they return. Hence, the calling function can deallocate or
+ ** modify the text after they return without harm.
+ ** The sqlite3_result_error_code() function changes the error code
+ ** returned by SQLite as a result of an error in a function. By default,
+ ** the error code is SQLITE_ERROR. A subsequent call to sqlite3_result_error()
+ ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
+ **
+ ** The sqlite3_result_toobig() interface causes SQLite to throw an error
+ ** indicating that a string or BLOB is to long to represent.
+ **
+ ** The sqlite3_result_nomem() interface causes SQLite to throw an error
+ ** indicating that a memory allocation failed.
+ **
+ ** The sqlite3_result_int() interface sets the return value
+ ** of the application-defined function to be the 32-bit signed integer
+ ** value given in the 2nd argument.
+ ** The sqlite3_result_int64() interface sets the return value
+ ** of the application-defined function to be the 64-bit signed integer
+ ** value given in the 2nd argument.
+ **
+ ** The sqlite3_result_null() interface sets the return value
+ ** of the application-defined function to be NULL.
+ **
+ ** The sqlite3_result_text(), sqlite3_result_text16(),
+ ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
+ ** set the return value of the application-defined function to be
+ ** a text string which is represented as UTF-8, UTF-16 native byte order,
+ ** UTF-16 little endian, or UTF-16 big endian, respectively.
+ ** SQLite takes the text result from the application from
+ ** the 2nd parameter of the sqlite3_result_text* interfaces.
+ ** If the 3rd parameter to the sqlite3_result_text* interfaces
+ ** is negative, then SQLite takes result text from the 2nd parameter
+ ** through the first zero character.
+ ** If the 3rd parameter to the sqlite3_result_text* interfaces
+ ** is non-negative, then as many bytes (not characters) of the text
+ ** pointed to by the 2nd parameter are taken as the application-defined
+ ** function result.
+ ** If the 4th parameter to the sqlite3_result_text* interfaces
+ ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
+ ** function as the destructor on the text or BLOB result when it has
+ ** finished using that result.
+ ** If the 4th parameter to the sqlite3_result_text* interfaces or
+ ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
+ ** assumes that the text or BLOB result is in constant space and does not
+ ** copy the it or call a destructor when it has finished using that result.
+ ** If the 4th parameter to the sqlite3_result_text* interfaces
+ ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
+ ** then SQLite makes a copy of the result into space obtained from
+ ** from [sqlite3_malloc()] before it returns.
+ **
+ ** The sqlite3_result_value() interface sets the result of
+ ** the application-defined function to be a copy the
+ ** [unprotected sqlite3_value] object specified by the 2nd parameter. The
+ ** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
+ ** so that the [sqlite3_value] specified in the parameter may change or
+ ** be deallocated after sqlite3_result_value() returns without harm.
+ ** A [protected sqlite3_value] object may always be used where an
+ ** [unprotected sqlite3_value] object is required, so either
+ ** kind of [sqlite3_value] object can be used with this interface.
+ **
+ ** If these routines are called from within the different thread
+ ** than the one containing the application-defined function that received
+ ** the [sqlite3_context] pointer, the results are undefined.
+ **
+ ** Requirements:
+ ** [H16403] [H16406] [H16409] [H16412] [H16415] [H16418] [H16421] [H16424]
+ ** [H16427] [H16430] [H16433] [H16436] [H16439] [H16442] [H16445] [H16448]
+ ** [H16451] [H16454] [H16457] [H16460] [H16463]
+ */
+ //SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
+ //SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
+ //SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
+ //SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
+ //SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
+ //SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
+ //SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
+ //SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
+ //SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
+ //SQLITE_API void sqlite3_result_null(sqlite3_context*);
+ //SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
+ //SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
+ //SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
+ //SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
+ //SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
+ //SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
+
+ /*
+ ** CAPI3REF: Define New Collating Sequences {H16600}
+ **
+ ** These functions are used to add new collation sequences to the
+ ** [database connection] specified as the first argument.
+ **
+ ** The name of the new collation sequence is specified as a UTF-8 string
+ ** for sqlite3_create_collation() and sqlite3_create_collation_v2()
+ ** and a UTF-16 string for sqlite3_create_collation16(). In all cases
+ ** the name is passed as the second function argument.
+ **
+ ** The third argument may be one of the constants [SQLITE_UTF8],
+ ** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied
+ ** routine expects to be passed pointers to strings encoded using UTF-8,
+ ** UTF-16 little-endian, or UTF-16 big-endian, respectively. The
+ ** third argument might also be [SQLITE_UTF16] to indicate that the routine
+ ** expects pointers to be UTF-16 strings in the native byte order, or the
+ ** argument can be [SQLITE_UTF16_ALIGNED] if the
+ ** the routine expects pointers to 16-bit word aligned strings
+ ** of UTF-16 in the native byte order.
+ **
+ ** A pointer to the user supplied routine must be passed as the fifth
+ ** argument. If it is NULL, this is the same as deleting the collation
+ ** sequence (so that SQLite cannot call it anymore).
+ ** Each time the application supplied function is invoked, it is passed
+ ** as its first parameter a copy of the void* passed as the fourth argument
+ ** to sqlite3_create_collation() or sqlite3_create_collation16().
+ **
+ ** The remaining arguments to the application-supplied routine are two strings,
+ ** each represented by a (length, data) pair and encoded in the encoding
+ ** that was passed as the third argument when the collation sequence was
+ ** registered. {END} The application defined collation routine should
+ ** return negative, zero or positive if the first string is less than,
+ ** equal to, or greater than the second string. i.e. (STRING1 - STRING2).
+ **
+ ** The sqlite3_create_collation_v2() works like sqlite3_create_collation()
+ ** except that it takes an extra argument which is a destructor for
+ ** the collation. The destructor is called when the collation is
+ ** destroyed and is passed a copy of the fourth parameter void* pointer
+ ** of the sqlite3_create_collation_v2().
+ ** Collations are destroyed when they are overridden by later calls to the
+ ** collation creation functions or when the [database connection] is closed
+ ** using [sqlite3_close()].
+ **
+ ** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
+ **
+ ** Requirements:
+ ** [H16603] [H16604] [H16606] [H16609] [H16612] [H16615] [H16618] [H16621]
+ ** [H16624] [H16627] [H16630]
+ */
+ //SQLITE_API int sqlite3_create_collation(
+ //// sqlite3*,
+ // const char *zName,
+ // int eTextRep,
+ // void*,
+ // int(*xCompare)(void*,int,const void*,int,const void*)
+ //);
+ //SQLITE_API int sqlite3_create_collation_v2(
+ //// sqlite3*,
+ // const char *zName,
+ // int eTextRep,
+ // void*,
+ // int(*xCompare)(void*,int,const void*,int,const void*),
+ // void(*xDestroy)(void*)
+ //);
+ //SQLITE_API int sqlite3_create_collation16(
+ //// sqlite3*,
+ // const void *zName,
+ // int eTextRep,
+ // void*,
+ // int(*xCompare)(void*,int,const void*,int,const void*)
+ //);
+
+ /*
+ ** CAPI3REF: Collation Needed Callbacks {H16700}
+ **
+ ** To avoid having to register all collation sequences before a database
+ ** can be used, a single callback function may be registered with the
+ ** [database connection] to be called whenever an undefined collation
+ ** sequence is required.
+ **
+ ** If the function is registered using the sqlite3_collation_needed() API,
+ ** then it is passed the names of undefined collation sequences as strings
+ ** encoded in UTF-8. {H16703} If sqlite3_collation_needed16() is used,
+ ** the names are passed as UTF-16 in machine native byte order.
+ ** A call to either function replaces any existing callback.
+ **
+ ** When the callback is invoked, the first argument passed is a copy
+ ** of the second argument to sqlite3_collation_needed() or
+ ** sqlite3_collation_needed16(). The second argument is the database
+ ** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE],
+ ** or [SQLITE_UTF16LE], indicating the most desirable form of the collation
+ ** sequence function required. The fourth parameter is the name of the
+ ** required collation sequence.
+ **
+ ** The callback function should register the desired collation using
+ ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
+ ** [sqlite3_create_collation_v2()].
+ **
+ ** Requirements:
+ ** [H16702] [H16704] [H16706]
+ */
+ //SQLITE_API int sqlite3_collation_needed(
+ // sqlite3*,
+ // void*,
+ // void(*)(void*,sqlite3*,int eTextRep,const char*)
+ //);
+ //SQLITE_API int sqlite3_collation_needed16(
+ // sqlite3*,
+ // void*,
+ // void(*)(void*,sqlite3*,int eTextRep,const void*)
+ //);
+
+ /*
+ ** Specify the key for an encrypted database. This routine should be
+ ** called right after sqlite3_open().
+ **
+ ** The code to implement this API is not available in the public release
+ ** of SQLite.
+ */
+ //SQLITE_API int sqlite3_key(
+ // sqlite3 *db, /* Database to be rekeyed */
+ // const void *pKey, int nKey /* The key */
+ //);
+
+ /*
+ ** Change the key on an open database. If the current database is not
+ ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
+ ** database is decrypted.
+ **
+ ** The code to implement this API is not available in the public release
+ ** of SQLite.
+ */
+ //SQLITE_API int sqlite3_rekey(
+ // sqlite3 *db, /* Database to be rekeyed */
+ // const void *pKey, int nKey /* The new key */
+ //);
+
+ /*
+ ** CAPI3REF: Suspend Execution For A Short Time {H10530}