| sqlite3_aggregate_context | Returns the state memory of the current aggregate function instance: the first call allocates nBytes of zeroed memory, later calls return the same buffer, and SQLite frees it when the aggregate concludes. Returns NULL when the first call passes nBytes of zero or less or runs out of memory. |
| sqlite3_auto_extension | Registers an entry point that SQLite calls for every new connection, where an error it returns fails the open; registering one twice is a no-op. Despite the void (*)(void) prototype SQLite calls it as int xEntryPoint(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pThunk), so its function table entry must have that type. |
| sqlite3_backup_finish | Releases the backup, rolling back an unfinished copy, and returns the result of the most recent sqlite3_backup_step if that failed, SQLITE_BUSY and SQLITE_LOCKED included, otherwise SQLITE_OK. Every backup sqlite3_backup_init returned needs it, also after an error. |
| sqlite3_backup_init | Prepares to copy the database zSourceName of pSource, such as main, into the database zDestName of pDest, which sqlite3_backup_step does, and returns the backup, or NULL with the error in pDest. It fails while pDest has any transaction open, when both are the same connection, and for an unknown database name. |
| sqlite3_backup_pagecount | Returns how many pages the source database had after the last sqlite3_backup_step that returned SQLITE_OK or SQLITE_DONE, or 0 before one did. |
| sqlite3_backup_remaining | Returns how many pages were left to copy after the last sqlite3_backup_step that returned SQLITE_OK or SQLITE_DONE, or 0 before one did. |
| sqlite3_backup_step | Copies up to nPage pages, or all that remain when nPage is negative. Returns SQLITE_DONE once every page is copied, SQLITE_OK while pages remain, SQLITE_BUSY or SQLITE_LOCKED when a lock prevents it for now, or another error, after which only sqlite3_backup_finish is useful. |
| sqlite3_bind_blob | Binds n bytes to a parameter; a negative n is undefined behavior. A NULL address binds SQL NULL, so an empty blob needs a non-NULL address. |
| sqlite3_bind_double | Binds a double to a parameter; SQLite stores NaN as NULL. |
| sqlite3_bind_int | Binds a 32-bit integer to a parameter. The wasm boundary converts the number with ToInt32, so a fraction is truncated and a value outside the int32 range wraps silently. |
| sqlite3_bind_int64 | Binds a 64-bit integer to a parameter. The wasm boundary wraps a bigint outside the int64 range silently. |
| sqlite3_bind_null | Binds NULL to a parameter. |
| sqlite3_bind_parameter_count | Returns the index of a statement's largest SQL parameter, which is the number of parameters unless ?NNN parameters leave gaps. |
| sqlite3_bind_parameter_index | Returns the 1-based index of the SQL parameter with a UTF-8 name that includes its prefix, such as :name, or 0 when no parameter matches. |
| sqlite3_bind_parameter_name | Returns the name of the SQL parameter at a 1-based index, including its prefix as in :name or ?NNN, or NULL for a nameless ? parameter or an index out of range. The statement owns the string. |
| sqlite3_bind_pointer | Binds SQL NULL carrying pPtr tagged with the type string zPType, which only sqlite3_value_pointer with an equal type string returns. The type string should be static because SQLite keeps its address, and SQLite calls xDestructor, unless NULL, with pPtr when done, even when binding fails. |
| sqlite3_bind_text | Binds UTF-8 text to a parameter: n bytes, which may include NUL characters, or up to the first NUL when n is negative. A NULL address binds SQL NULL. |
| sqlite3_bind_zeroblob | Binds a blob of n zero bytes to a parameter without allocating its content; a negative n binds a zero-length blob. |
| sqlite3_busy_handler | Sets the connection's only busy handler, replacing any other, including the one sqlite3_busy_timeout sets, or removes it for NULL so a lock fails with SQLITE_BUSY at once. SQLite calls it with pArg and the number of earlier calls for the same lock and retries while it returns non-zero; it must not modify the connection. |
| sqlite3_busy_timeout | Sets a busy handler that sleeps and retries until at least ms milliseconds have passed, replacing any other busy handler; ms of zero or less removes all busy handlers. |
| sqlite3_cancel_auto_extension | Unregisters an entry point sqlite3_auto_extension registered, returning 1 when it was registered and 0 otherwise. |
| sqlite3_changes | Returns the rows changed by the connection's most recently completed INSERT, UPDATE or DELETE, without changes by triggers, foreign key actions or REPLACE; other statements leave it unchanged, except a DROP TABLE that, with foreign keys on, first deletes the rows of a table that foreign keys reference. The result is undefined above the int range, which sqlite3_changes64 covers. |
| sqlite3_changes64 | Returns the rows changed by the connection's most recently completed INSERT, UPDATE or DELETE, without changes by triggers, foreign key actions or REPLACE; other statements leave it unchanged, except a DROP TABLE that, with foreign keys on, first deletes the rows of a table that foreign keys reference. |
| sqlite3_clear_bindings | Sets every parameter of a statement to NULL, which sqlite3_reset does not do. |
| sqlite3_close_v2 | Closes a connection. With unfinalized statements the close is deferred and the connection keeps its files open. |
| sqlite3_collation_needed | Sets the connection's callback for an undefined collation sequence, replacing the previous one. SQLite calls it with pArg, the connection, the preferred text encoding and the UTF-8 collation name, and the callback should register that collation. |
| sqlite3_column_blob | Returns the address of a result column's bytes, or NULL for a zero-length blob, SQL NULL or out of memory; call it before sqlite3_column_bytes. The memory stays valid until a type conversion of the column or the next step, reset or finalize, and SQLite frees it. |
| sqlite3_column_bytes | Returns the byte length of the text or blob the preceding column call returned. |
| sqlite3_column_count | Returns the number of result columns of a statement. |
| sqlite3_column_decltype | Returns the declared type of the table column a result column comes from, or NULL when the result column is an expression or subquery. The statement owns the string. |
| sqlite3_column_double | Returns a result column of the current row as a double, converting other types, such as NULL to 0.0. |
| sqlite3_column_int | Returns a result column of the current row as a 32-bit integer, converting other types; an integer outside the 32-bit range keeps only its low 32 bits. |
| sqlite3_column_int64 | Returns a result column of the current row as a 64-bit integer, converting other types as CAST does, and 0 for NULL. |
| sqlite3_column_name | Returns the name of a result column, which is its AS alias or else unspecified, or NULL when out of memory or the index is out of range. The statement owns the string until it is finalized or re-prepared. |
| sqlite3_column_text | Returns the address of a result column as NUL-terminated UTF-8 text that can contain NUL characters, so read its length with sqlite3_column_bytes afterwards. Returns NULL for SQL NULL and when out of memory, which sqlite3_errcode tells apart; the text stays valid until the next step, reset or finalize, or a conversion by another column call. |
| sqlite3_column_type | Returns the storage class of a result column in the current row. Read it before any other column function, which can convert the value. |
| sqlite3_column_value | Returns a result column of the current row as an unprotected sqlite3_value, valid until the next step, reset or finalize. This build is single-threaded (SQLITE_THREADSAFE=0), so an unprotected value works wherever a protected one does, and sqlite3_value_dup copies it to outlive the row. |
| sqlite3_commit_hook | Sets the connection's commit callback, replacing the previous one, or removes it for NULL, and returns the previous call's pArg, NULL for the first call. SQLite calls it with pArg before each commit and turns the commit into a rollback when it returns non-zero; it must not modify the connection. |
| sqlite3_compileoption_get | Returns the N-th option defined at compile time, without its SQLITE_ prefix, or NULL when N is out of range. The string is static. |
| sqlite3_compileoption_used | Returns 1 if the named option, with or without its SQLITE_ prefix, was defined at compile time, and 0 otherwise. |
| sqlite3_complete | Returns 1 when UTF-8 SQL text ends with a complete statement, a final semicolon token that does not end inside a CREATE TRIGGER body, and 0 otherwise. A line comment ends only at a newline, so SQL that ends inside one is incomplete. It tokenizes without parsing, so it does not detect invalid SQL. |
| sqlite3_config | Changes a global option of the library, which works only before sqlite3_initialize or after sqlite3_shutdown and otherwise returns SQLITE_MISUSE. The loader initializes the library, so call it after sqlite3_shutdown, then initialize the library again with initializeSqliteWasm, as sqlite3_shutdown explains. |
| sqlite3_context_db_handle | Returns the connection that registered the application-defined function being called. |
| sqlite3_create_collation | Adds, replaces or, with a NULL xCompare, removes a collation named zName for text in the eTextRep encoding. xCompare(pArg, n1, s1, n2, s2) compares two strings of the given byte lengths and returns a negative number, zero or a positive number; SQLite behavior is undefined when the comparison is inconsistent. |
| sqlite3_create_collation_v2 | Works like sqlite3_create_collation, and SQLite calls a non-NULL xDestroy with pArg when the collation is replaced or the connection closes. Unlike other SQLite functions, it does not call xDestroy when this call fails, so the caller then disposes of pArg. |
| sqlite3_create_function | Adds, redefines or, with xFunc, xStep and xFinal all NULL, removes an SQL function of the connection: xFunc implements a scalar function, xStep with xFinal an aggregate. nArg is the argument count or -1 for any, and eTextRep the preferred text encoding, optionally with flags such as SQLITE_DETERMINISTIC and SQLITE_DIRECTONLY. |
| sqlite3_create_function_v2 | Works like sqlite3_create_function, and SQLite calls a non-NULL xDestroy with pApp when the function is redefined or removed, when the connection closes, and when this call fails. |
| sqlite3_data_count | Returns the number of columns in the statement's current row, or 0 when the last step did not return SQLITE_ROW or the statement is NULL. |
| sqlite3_db_config | Changes or reads an option of a connection, returning SQLITE_OK or an error code. |
| sqlite3_db_filename | Returns the absolute filename of a schema of the connection, valid until the schema is detached or the connection closes, or NULL or an empty string for a temporary or in-memory database or an unknown schema. A non-NULL result can be passed to the sqlite3_uri_* functions. |
| sqlite3_db_handle | Returns the connection a prepared statement belongs to. |
| sqlite3_db_name | Returns the schema name of the connection's N-th database, where 0 is main and 1 is temp, or NULL when N is out of range. SQLite owns the string, which any schema change, such as ATTACH, DETACH, sqlite3_serialize or sqlite3_deserialize, can free. |
| sqlite3_db_readonly | Returns 1 if a schema of the connection is read-only, 0 if it is read/write, or -1 when no schema has that name. |
| sqlite3_db_status | Writes the current and highest values of a connection status counter to pCur and pHiwtr, resetting the highest to the current value when resetFlg is non-zero. Values above the int range are truncated; sqlite3_db_status64 returns them in full. |
| sqlite3_db_status64 | Reads a connection's SQLITE_DBSTATUS_* counter into the sqlite3_int64 at pCur and its highwater mark into the sqlite3_int64 at pHiwtr, 8 bytes each, resetting the mark to the current value when resetFlg is non-zero. |
| sqlite3_deserialize | Reopens a schema, main for NULL, as an in-memory database over the first szDb bytes of a szBuf-byte buffer, which must stay valid and unmodified until the connection closes. szBuf must be at least szDb, and about 20 bytes more for content that may be malformed, which SQLite may read a few bytes past. With SQLITE_DESERIALIZE_FREEONCLOSE, SQLite takes ownership of the sqlite3_malloc'd buffer and frees it, even when deserializing fails. |
| sqlite3_errcode | Returns the result code of the connection's most recent API call if that call failed, as a primary code unless extended result codes are enabled. |
| sqlite3_errmsg | Returns the English message of the connection's most recent error, or NULL when none is available. SQLite owns the string, which the next call on the connection can overwrite or free. |
| sqlite3_error_offset | Returns the byte offset in the SQL of the most recent error, or -1. |
| sqlite3_errstr | Returns the English description of a result code, or NULL when none is available. The string is static and must not be freed. |
| sqlite3_exec | Runs zero or more semicolon-separated UTF-8 SQL statements, stopping at the first error, and calls the callback, unless NULL, with pArg for each result row; a non-zero callback result stops with SQLITE_ABORT. Unless errmsg is NULL, it receives NULL on success or an error message the caller frees with sqlite3_free. |
| sqlite3_expanded_sql | Returns the statement's SQL with bound parameters expanded as literals, in memory the caller frees with sqlite3_free, or NULL when out of memory, above SQLITE_LIMIT_LENGTH, or when built with SQLITE_OMIT_TRACE. |
| sqlite3_extended_errcode | Returns the connection's most recent extended result code. |
| sqlite3_extended_result_codes | Enables extended result codes for the connection when onoff is non-zero and disables them otherwise. They are disabled by default, and sqlite3_extended_errcode returns them regardless. |
| sqlite3_file_control | Calls the xFileControl method of a schema's file, main for a NULL zDbName, with an opcode and its argument and returns its result; the core handles a few opcodes, such as SQLITE_FCNTL_FILE_POINTER, itself. An unknown schema returns SQLITE_ERROR without recording it for sqlite3_errcode. |
| sqlite3_finalize | Destroys a prepared statement and returns the error of its most recent evaluation if that failed, otherwise SQLITE_OK; NULL is a harmless no-op. |
| sqlite3_free | Frees memory from sqlite3_malloc or from a SQLite function that returns owned memory. |
| sqlite3_get_autocommit | Returns 0 from BEGIN until the COMMIT or ROLLBACK that ends the transaction, and non-zero otherwise. It is the only way to tell whether SQLite rolled back a transaction automatically after an error such as SQLITE_FULL or SQLITE_BUSY. |
| sqlite3_get_auxdata | Returns the auxiliary data sqlite3_set_auxdata associated with the 0-based N-th argument of the current function call, or NULL when there is none or SQLite discarded it. |
| sqlite3_initialize | Initializes the library, returning SQLITE_OK or an error code. Once the library is initialized, further calls are harmless no-ops until sqlite3_shutdown. |
| sqlite3_interrupt | Stops the connection's running statements, and statements started before they all finish, at their earliest opportunity with SQLITE_INTERRUPT; an interrupted write in an explicit transaction rolls the transaction back. With no running statement it does nothing. |
| sqlite3_is_interrupted | Returns 1 while an sqlite3_interrupt is in effect for the connection, and 0 otherwise. |
| sqlite3_keyword_check | Returns non-zero if the nName bytes of UTF-8 at zName, which need no NUL terminator, are an SQL keyword in any letter case, and 0 otherwise. |
| sqlite3_keyword_count | Returns the number of distinct SQL keywords the library recognizes, which depends on compile-time options. |
| sqlite3_keyword_name | Writes the address and byte length of the 0-based index-th SQL keyword, UTF-8 without a NUL terminator in static memory, and returns SQLITE_ERROR when the index is out of range. Both output pointers must be valid. |
| sqlite3_last_insert_rowid | Returns the rowid of the connection's most recent successful INSERT into a rowid table, or 0 if there was none. Inside a trigger it returns the trigger's insert until the trigger ends, and a failed INSERT leaves it unchanged. |
| sqlite3_libversion | Returns the library's version string, the SQLITE_VERSION it was built with, in static memory. |
| sqlite3_libversion_number | Returns the SQLITE_VERSION_NUMBER the library was built with. |
| sqlite3_limit | Sets a run-time limit of the connection and returns its prior value; a negative newVal only reads it, and a value above the compile-time maximum is lowered to that maximum. |
| sqlite3_malloc | Allocates at least byteLength bytes, returning NULL when out of memory or when byteLength is zero or negative. |
| sqlite3_malloc64 | Allocates memory like sqlite3_malloc with a 64-bit size, returning NULL when out of memory or for zero bytes. |
| sqlite3_msize | Returns the usable byte size of memory from sqlite3_malloc, sqlite3_realloc or their 64-bit variants, which can exceed the requested size, or 0 for NULL. |
| sqlite3_next_stmt | Returns the connection's first prepared statement for a NULL pStmt, otherwise the one after pStmt, or NULL when there is none. |
| sqlite3_open | Opens a database connection for reading and writing, creating the database when it does not exist, with the default VFS. SQLite writes a handle even when opening fails, except when out of memory, and that handle must be closed. |
| sqlite3_open_v2 | Opens a database connection. SQLite writes a handle even when opening fails, except when out of memory, and that handle must be closed. |
| sqlite3_overload_function | Ensures a global SQL function with this name and argument count exists, creating a placeholder that raises an error when called, so a virtual table's xFindFunction can overload it. |
| sqlite3_prepare_v2 | Compiles the first statement of UTF-8 SQL as sqlite3_prepare_v3 does with no flags, reading at most nByte bytes or up to a NUL when nByte is negative, and writes the statement to *ppStmt and the address of the uncompiled rest to *pzTail. *ppStmt is NULL on error and for SQL without a statement, such as only a comment; the caller finalizes a non-NULL one. |
| sqlite3_prepare_v3 | Compiles the first statement of UTF-8 SQL, reading at most nByte bytes or up to a NUL when nByte is negative, and writes the statement to *ppStmt and the address of the uncompiled rest to *pzTail. *ppStmt is NULL on error and for SQL without a statement, such as only a comment; the caller finalizes a non-NULL one. |
| sqlite3_randomness | Writes N pseudo-random bytes to P. A call with N below 1 or a NULL P writes nothing and makes the next call reseed from the default VFS's xRandomness. |
| sqlite3_realloc | Resizes memory from sqlite3_malloc, keeping its leading bytes, and returns the new address, after which the old one is invalid. A NULL pointer allocates, a size of 0 or less frees and returns NULL, and when out of memory it returns NULL and leaves the old allocation intact. |
| sqlite3_realloc64 | Resizes memory from sqlite3_malloc, moving its contents to the returned address; NULL memory allocates, and a zero size frees it and returns NULL. When out of memory it returns NULL and leaves the old memory allocated. |
| sqlite3_reset | Resets a statement so it can run again, keeping its bindings. It returns the error of a failed most recent step, and can fail on its own, such as with SQLITE_BUSY when an INSERT with RETURNING stepped only once cannot commit. |
| sqlite3_reset_auto_extension | Unregisters every entry point sqlite3_auto_extension registered. |
| sqlite3_result_blob | Sets an application-defined function's result to n bytes. A NULL address sets SQL NULL, as for sqlite3_bind_blob, so an empty blob needs a non-NULL address or sqlite3_result_zeroblob. |
| sqlite3_result_double | Sets an application-defined function's result to a double; SQLite stores NaN as NULL. |
| sqlite3_result_error | Makes an application-defined function fail with a copy of a UTF-8 message of n bytes, or up to its NUL terminator when n is negative. It resets the error code to SQLITE_ERROR, so call sqlite3_result_error_code after it. |
| sqlite3_result_error_code | Makes an application-defined function fail with a result code instead of SQLITE_ERROR, and with the code's default message when no result was set. Call it after sqlite3_result_error, which resets the code to SQLITE_ERROR. |
| sqlite3_result_error_nomem | Makes an application-defined function fail with SQLITE_NOMEM, as a failed memory allocation would. |
| sqlite3_result_error_toobig | Makes an application-defined function fail with SQLITE_TOOBIG, reporting a string or blob too big to represent. |
| sqlite3_result_int | Sets an application-defined function's result to a 32-bit integer. The wasm boundary converts the number with ToInt32, so a fraction is truncated and a value outside the int32 range wraps silently. |
| sqlite3_result_int64 | Sets an application-defined function's result to a 64-bit integer. The wasm boundary wraps a bigint outside the int64 range silently. |
| sqlite3_result_null | Sets an application-defined function's result to NULL. |
| sqlite3_result_pointer | Sets an application-defined function's result to an SQL NULL carrying pPtr, which sqlite3_value_pointer returns for an equal type name. SQLite keeps zPType itself, so it must outlive the value, and calls a non-NULL xDestructor with pPtr when done with it. |
| sqlite3_result_subtype | Sets the subtype of an application-defined function's result, keeping only its low 8 bits. The function must be registered with SQLITE_RESULT_SUBTYPE: without it the subtype might not be set, and a build with SQLITE_STRICT_SUBTYPE, such as this one, fails the function with an error. SQLite's table declares the first parameter as sqlite3_value*, but the C function takes sqlite3_context*. |
| sqlite3_result_text | Sets an application-defined function's result to UTF-8 text of n bytes, or up to its NUL terminator when n is negative. A NULL address sets SQL NULL, as for sqlite3_bind_text. |
| sqlite3_result_zeroblob | Sets an application-defined function's result to a blob of n zero bytes, 0 for a negative n. A size beyond SQLITE_LIMIT_LENGTH makes the function fail with SQLITE_TOOBIG. |
| sqlite3_result_zeroblob64 | Sets an application-defined function's result to a blob of n zero bytes. Returns SQLITE_TOOBIG, and makes the function fail with that error, when n exceeds the connection's length limit. |
| sqlite3_rollback_hook | Registers the callback SQLite calls with pArg whenever a transaction rolls back, except when closing the connection, replacing the previous one; NULL removes it. Returns the previous pArg or NULL; the callback must not use the connection, not even to prepare or step a statement. |
| sqlite3_serialize | Copies a schema, NULL meaning main, into memory from sqlite3_malloc64 that the caller frees, writing its byte size as an 8-byte sqlite3_int64 to piSize unless NULL. An empty database first gets its first page from an empty write transaction. Pages are read through the pager, so an encrypted database comes out decrypted, and a page that fails to read comes out zero-filled. Returns NULL when out of memory, for an unknown schema or a database without pages, and with SQLITE_SERIALIZE_NOCOPY returns SQLite's own buffer of a deserialized database, or NULL, instead of a copy, which the caller must neither free nor modify. Only a call whose mFlags is 0 returns memory sqlite3_free accepts. |
| sqlite3_set_auxdata | Attaches pAux to the N-th argument of the running application-defined function, where sqlite3_get_auxdata finds it while the argument stays the same. SQLite may discard it at any time, even before this call returns, calling a non-NULL xDelete with pAux, so pAux must not be used afterwards. |
| sqlite3_set_errmsg | Sets the error code and a copy of zErrMsg, or the code's default message for NULL, that sqlite3_errcode and sqlite3_errmsg report for a connection until SQLite or another call replaces them. |
| sqlite3_set_last_insert_rowid | Sets the value sqlite3_last_insert_rowid returns for the connection without inserting a row. |
| sqlite3_shutdown | Deallocates the resources sqlite3_initialize allocated. Every connection must be closed and every other SQLite resource freed first; only the first call after an initialization has an effect. Then initialize the library again with initializeSqliteWasm. sqlite3_initialize alone, or any call that initializes the library itself, such as an open, makes the unix VFS the default again, from which the generator of sqlite3_randomness, when reset or unused since loading, seeds itself with the time and a constant pid instead of RandomBytes, and registers kvvfs again, which traps when :localStorage: is opened. |
| sqlite3_sourceid | Returns the date, time and check-in hash of the SQLite source the library was built from, as a static string. |
| sqlite3_sql | Returns the SQL text a statement was prepared from, which SQLite frees when the statement is finalized, or NULL for a statement from the legacy sqlite3_prepare, which this build does not export. |
| sqlite3_status | Reads a global SQLITE_STATUS_* counter into *pCurrent and its highwater mark into *pHighwater, resetting the mark when resetFlag is non-zero. A counter that tracks only one of the two leaves the other unwritten, and values beyond 32 bits are undefined. |
| sqlite3_status64 | Reads a global SQLITE_STATUS_* counter into the sqlite3_int64 at pCurrent and its highwater mark into the sqlite3_int64 at pHighwater, 8 bytes each, resetting the mark when resetFlag is non-zero. Some counters leave one of the two outputs unwritten. |
| sqlite3_step | Evaluates a statement one step, returning SQLITE_ROW, SQLITE_DONE or an error. |
| sqlite3_stmt_busy | Returns non-zero when a statement has been stepped but has neither returned SQLITE_DONE nor been reset, and 0 for NULL. |
| sqlite3_stmt_explain | Makes a statement behave as if its SQL began with EXPLAIN (eMode 1), EXPLAIN QUERY PLAN (2) or neither (0), possibly re-preparing it. It fails while the statement is active, so reset it first. |
| sqlite3_stmt_isexplain | Returns 1 for an EXPLAIN statement, 2 for EXPLAIN QUERY PLAN, and 0 for an ordinary statement or NULL. |
| sqlite3_stmt_readonly | Returns non-zero when a statement cannot directly change the database file, though application-defined functions or virtual tables it calls still might. Transaction control, ATTACH and DETACH count as read-only; BEGIN IMMEDIATE, BEGIN EXCLUSIVE and any statement that might write do not. |
| sqlite3_stmt_status | Returns one of a statement's SQLITE_STMTSTATUS_* counters, and resets it to 0 afterwards when resetFlg is non-zero. |
| sqlite3_strglob | Returns 0 when zStr matches the GLOB pattern zGlob, case-sensitively as SQL's GLOB operator does, and non-zero otherwise. |
| sqlite3_stricmp | Compares two UTF-8 strings, folding only ASCII case as SQLite does for identifiers, and returns 0 when they are equal or a negative or positive number that orders them. |
| sqlite3_strlike | Returns 0 when zStr matches the LIKE pattern zGlob with escape character cEsc, or none for 0, and non-zero otherwise. Like SQL's LIKE operator, it folds only ASCII case. |
| sqlite3_strnicmp | Compares at most N bytes of two UTF-8 strings, folding only ASCII case as SQLite does for identifiers, and returns 0 when they are equal or a negative or positive number that orders them. |
| sqlite3_table_column_metadata | Writes a table column's declared type, collation sequence and NOT NULL, PRIMARY KEY and AUTOINCREMENT flags through the non-NULL output pointers, failing for a missing column or a view; a NULL column name only checks that the table exists. The returned strings stay valid only until the next SQLite call. |
| sqlite3_total_changes | Returns the rows inserted, updated or deleted by the connection's completed statements since it opened, including those of triggers and foreign key actions. The result is undefined beyond the int range, which sqlite3_total_changes64 avoids. |
| sqlite3_total_changes64 | Returns the number of rows changed by INSERT, UPDATE and DELETE statements on the connection since it opened, counting trigger and foreign key action changes but not REPLACE conflict deletions. Other connections do not change it, and other statements do not either, except a DROP TABLE that, with foreign keys on, first deletes the rows of a table that foreign keys reference. |
| sqlite3_trace_v2 | Registers the connection's one trace callback for the SQLITE_TRACE_* events in uMask, replacing any previous one; a NULL callback or a zero mask disables tracing. The callback receives the event code, pCtx and two event-specific pointers, and should return 0. |
| sqlite3_txn_state | Returns a schema's transaction state, SQLITE_TXN_NONE, SQLITE_TXN_READ or SQLITE_TXN_WRITE, the highest across all schemas for NULL, or -1 for an unknown schema. |
| sqlite3_update_hook | Registers the connection's callback for each row inserted, updated or deleted in a rowid table, replacing the previous one or removing it for NULL, and returns the previous pArg or NULL. The callback must not modify the connection and does not fire for WITHOUT ROWID tables, REPLACE conflict deletions or the truncate optimization. |
| sqlite3_uri_boolean | Returns 1 when a filename's URI query parameter is yes, true or on in any case or starts with a non-zero number, 0 when it is no, false or off or starts with zero, and whether bDefault is non-zero otherwise, including for a NULL filename. |
| sqlite3_uri_int64 | Returns a URI query parameter of a filename SQLite created as a 64-bit integer, or iDefault when the filename is NULL or the parameter is missing or not a decimal or hexadecimal integer. |
| sqlite3_uri_key | Returns the name of a filename's N-th URI query parameter, counting from 0, or NULL when N is out of range. |
| sqlite3_uri_parameter | Returns the value of a URI query parameter of a filename, an empty string for a parameter without a value, or NULL when it is absent or the filename is NULL. |
| sqlite3_user_data | Returns the user data pointer the running application-defined function was registered with. |
| sqlite3_value_blob | Returns the address of a value's bytes, rendering a number as text, or NULL for a zero-length value or SQL NULL. Call it before sqlite3_value_bytes; a later text conversion invalidates the address. |
| sqlite3_value_bytes | Returns the byte length of the blob or UTF-8 text the preceding sqlite3_value_blob or sqlite3_value_text call returned, without the NUL terminator; 0 for NULL. |
| sqlite3_value_double | Returns a value as a double, converting other types as CAST does, and 0.0 for NULL. |
| sqlite3_value_dup | Copies a value into a protected value the caller frees with sqlite3_value_free. Returns NULL for NULL or when out of memory, and a pointer value copies as SQL NULL. |
| sqlite3_value_free | Frees a value from sqlite3_value_dup; NULL is a no-op. |
| sqlite3_value_frombind | Returns non-zero when a value came from a bound parameter rather than a literal, a column or an expression. |
| sqlite3_value_int | Returns a value as a 32-bit integer, converting other types as CAST does and truncating a larger integer to its low 32 bits, and 0 for NULL. |
| sqlite3_value_int64 | Returns a value as a 64-bit integer, converting other storage classes as sqlite3_column_int64 does. |
| sqlite3_value_nochange | Within a virtual table's xUpdate, returns non-zero when the value's column is unchanged by the UPDATE because xColumn set no result; such a value otherwise looks like NULL. Anywhere else the result is meaningless. |
| sqlite3_value_numeric_type | Converts a value that looks like a number to INTEGER or FLOAT when no information is lost, and returns its resulting fundamental data type. |
| sqlite3_value_pointer | Returns the pointer sqlite3_bind_pointer or sqlite3_result_pointer attached to a value under a type name equal to zPType by strcmp, and NULL otherwise. |
| sqlite3_value_subtype | Returns the subtype of an application-defined function argument, as sqlite3_result_subtype set it, or 0. The reading function should be registered with SQLITE_SUBTYPE, or it might get 0 in corner cases. |
| sqlite3_value_text | Returns the address of a protected value as NUL-terminated UTF-8 text that can contain NUL characters, so read its length with sqlite3_value_bytes afterwards. Returns NULL for SQL NULL and when out of memory, and a later call that converts the value can invalidate the text. |
| sqlite3_value_type | Returns a value's initial fundamental data type. Read it before the other value functions, whose conversions can change it. |
| sqlite3_vfs_find | Returns a registered VFS by name, or the default VFS for NULL. |
| sqlite3_vfs_register | Registers a VFS, optionally as the default. The struct and its name must outlive the registration. |
| sqlite3_vfs_unregister | Unregisters a VFS. When it was the default, SQLite makes an arbitrary other VFS the default. |
| sqlite3_vtab_collation | Returns the collation name for text comparisons of an xBestIndex constraint, BINARY by default, or NULL for an index outside aConstraint. Only xBestIndex may call it, with the sqlite3_index_info it received. |
| sqlite3_vtab_config | Sets an option of the virtual table whose xCreate or xConnect method is running, the only place it may be called. |
| sqlite3_vtab_distinct | Returns how the planner needs a virtual table's rows for orderByConsumed: 0 in aOrderBy order, 1 with equal aOrderBy values adjacent, 2 adjacent with duplicates over colUsed omittable, 3 in order with such duplicates omittable. Only xBestIndex may call it. |
| sqlite3_vtab_in | Returns non-zero when constraint iCons is an IN operator that can be processed all at once; bHandle 1 or 0 requests or declines that processing, and -1 only asks. Only xBestIndex may call it. |
| sqlite3_vtab_in_first | Writes the first right-hand value of an all-at-once IN constraint, given its xFilter argument, to ppOut and returns SQLITE_OK, or writes NULL and returns SQLITE_DONE when there is none. The value stays valid until the next call or the end of xFilter. |
| sqlite3_vtab_in_next | Writes the next right-hand value of an all-at-once IN constraint, given its xFilter argument, to ppOut and returns SQLITE_OK, or writes NULL and returns SQLITE_DONE after the last. The value stays valid until the next call or the end of xFilter. |
| sqlite3_vtab_nochange | Returns non-zero inside xColumn when the column is fetched for an UPDATE that does not change it, so xColumn may leave the result unset. It is only a hint and may always return 0. |
| sqlite3_vtab_on_conflict | Returns the ON CONFLICT mode of the statement that called xUpdate for an INSERT or UPDATE: SQLITE_ROLLBACK, SQLITE_IGNORE, SQLITE_FAIL, SQLITE_ABORT or SQLITE_REPLACE. Only xUpdate may call it. |
| sqlite3_vtab_rhs_value | Writes the right-hand value of constraint iCons to ppVal and returns SQLITE_OK, or writes NULL and returns SQLITE_NOTFOUND when it is not known, which is usual unless it is a literal. Only xBestIndex may call it, and the value is freed when xBestIndex returns. |