bin

func X_start ¶

func X_start(tls *crt.TLS, _argc int32, _argv **int8)

func Xmain ¶

func Xmain(tls *crt.TLS, _argc int32, _argv **int8) (r0 int32)

func Xsqlite3PendingByte ¶

func Xsqlite3PendingByte() int32

func Xsqlite3_aggregate_context ¶

func Xsqlite3_aggregate_context(tls *crt.TLS, _p *Xsqlite3_context, _nByte int32) (r0 unsafe.Pointer)

C comment

/*
** Allocate or return the aggregate context for a user function.  A new
** context is allocated on the first call.  Subsequent calls return the
** same context that was returned on prior calls.
*/

func Xsqlite3_aggregate_count ¶

func Xsqlite3_aggregate_count(tls *crt.TLS, _p *Xsqlite3_context) (r0 int32)

C comment

/*
** Return the number of times the Step function of an aggregate has been
** called.
**
** This function is deprecated.  Do not use it for new code.  It is
** provide only to avoid breaking legacy code.  New aggregate function
** implementations should keep their own counts within their aggregate
** context.
*/

func Xsqlite3_auto_extension ¶

func Xsqlite3_auto_extension(tls *crt.TLS, _xInit func(*crt.TLS)) (r0 int32)

C comment

/*
** Register a statically linked extension that is automatically
** loaded by every new database connection.
*/

func Xsqlite3_backup_finish ¶

func Xsqlite3_backup_finish(tls *crt.TLS, _p *Xsqlite3_backup) (r0 int32)

C comment

/*
** Release all resources associated with an sqlite3_backup* handle.
*/

func Xsqlite3_backup_pagecount ¶

func Xsqlite3_backup_pagecount(tls *crt.TLS, _p *Xsqlite3_backup) (r0 int32)

C comment

/*
** Return the total number of pages in the source database as of the most
** recent call to sqlite3_backup_step().
*/

func Xsqlite3_backup_remaining ¶

func Xsqlite3_backup_remaining(tls *crt.TLS, _p *Xsqlite3_backup) (r0 int32)

C comment

/*
** Return the number of pages still to be backed up as of the most recent
** call to sqlite3_backup_step().
*/

func Xsqlite3_backup_step ¶

func Xsqlite3_backup_step(tls *crt.TLS, _p *Xsqlite3_backup, _nPage int32) (r0 int32)

C comment

/*
** Copy nPage pages from the source b-tree to the destination.
*/

func Xsqlite3_bind_blob ¶

func Xsqlite3_bind_blob(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _zData unsafe.Pointer, _nData int32, _xDel func(*crt.TLS, unsafe.Pointer)) (r0 int32)

C comment

/*
** Bind a blob value to an SQL statement variable.
*/

func Xsqlite3_bind_blob64 ¶

func Xsqlite3_bind_blob64(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _zData unsafe.Pointer, _nData uint64, _xDel func(*crt.TLS, unsafe.Pointer)) (r0 int32)

func Xsqlite3_bind_double ¶

func Xsqlite3_bind_double(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _rValue float64) (r0 int32)

func Xsqlite3_bind_int ¶

func Xsqlite3_bind_int(tls *crt.TLS, _p unsafe.Pointer, _i int32, _iValue int32) (r0 int32)

func Xsqlite3_bind_int64 ¶

func Xsqlite3_bind_int64(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _iValue int64) (r0 int32)

func Xsqlite3_bind_null ¶

func Xsqlite3_bind_null(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int32)

func Xsqlite3_bind_parameter_count ¶

func Xsqlite3_bind_parameter_count(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return the number of wildcards that can be potentially bound to.
** This routine is added to support DBD::SQLite.
*/

func Xsqlite3_bind_parameter_index ¶

func Xsqlite3_bind_parameter_index(tls *crt.TLS, _pStmt unsafe.Pointer, _zName *int8) (r0 int32)

C comment

/*
** CAPI3REF: Index Of A Parameter With A Given Name
** METHOD: sqlite3_stmt
**
** ^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_name()].
*/

func Xsqlite3_bind_parameter_name ¶

func Xsqlite3_bind_parameter_name(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 *int8)

C comment

/*
** Return the name of a wildcard parameter.  Return NULL if the index
** is out of range or if the wildcard is unnamed.
**
** The result is always UTF-8.
*/

func Xsqlite3_bind_text ¶

func Xsqlite3_bind_text(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _zData *int8, _nData int32, _xDel func(*crt.TLS, unsafe.Pointer)) (r0 int32)

func Xsqlite3_bind_text16 ¶

func Xsqlite3_bind_text16(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _zData unsafe.Pointer, _nData int32, _xDel func(*crt.TLS, unsafe.Pointer)) (r0 int32)

func Xsqlite3_bind_text64 ¶

func Xsqlite3_bind_text64(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _zData *int8, _nData uint64, _xDel func(*crt.TLS, unsafe.Pointer), _enc uint8) (r0 int32)

func Xsqlite3_bind_value ¶

func Xsqlite3_bind_value(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _pValue *XMem) (r0 int32)

C comment

/* SQLITE_OMIT_UTF16 */

func Xsqlite3_bind_zeroblob ¶

func Xsqlite3_bind_zeroblob(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _n int32) (r0 int32)

func Xsqlite3_bind_zeroblob64 ¶

func Xsqlite3_bind_zeroblob64(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32, _n uint64) (r0 int32)

func Xsqlite3_blob_bytes ¶

func Xsqlite3_blob_bytes(tls *crt.TLS, _pBlob unsafe.Pointer) (r0 int32)

C comment

/*
** Query a blob handle for the size of the data.
**
** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
** so no mutex is required for access.
*/

func Xsqlite3_blob_close ¶

func Xsqlite3_blob_close(tls *crt.TLS, _pBlob unsafe.Pointer) (r0 int32)

C comment

/*
** Close a blob handle that was previously created using
** sqlite3_blob_open().
*/

func Xsqlite3_blob_open ¶

func Xsqlite3_blob_open(tls *crt.TLS, _db *Xsqlite3, _zDb *int8, _zTable *int8, _zColumn *int8, _iRow int64, _wrFlag int32, _ppBlob *unsafe.Pointer) (r0 int32)

C comment

/*
** Open a blob handle.
*/

func Xsqlite3_blob_read ¶

func Xsqlite3_blob_read(tls *crt.TLS, _pBlob unsafe.Pointer, _z unsafe.Pointer, _n int32, _iOffset int32) (r0 int32)

C comment

/*
** Read data from a blob handle.
*/

func Xsqlite3_blob_reopen ¶

func Xsqlite3_blob_reopen(tls *crt.TLS, _pBlob unsafe.Pointer, _iRow int64) (r0 int32)

C comment

/*
** Move an existing blob handle to point to a different row of the same
** database table.
**
** If an error occurs, or if the specified row does not exist or does not
** contain a blob or text value, then an error code is returned and the
** database handle error code and message set. If this happens, then all
** subsequent calls to sqlite3_blob_xxx() functions (except blob_close())
** immediately return SQLITE_ABORT.
*/

func Xsqlite3_blob_write ¶

func Xsqlite3_blob_write(tls *crt.TLS, _pBlob unsafe.Pointer, _z unsafe.Pointer, _n int32, _iOffset int32) (r0 int32)

C comment

/*
** Write data to a blob handle.
*/

func Xsqlite3_busy_handler ¶

func Xsqlite3_busy_handler(tls *crt.TLS, _db *Xsqlite3, _xBusy func(*crt.TLS, unsafe.Pointer, int32) int32, _pArg unsafe.Pointer) (r0 int32)

C comment

/*
** This routine sets the busy callback for an Sqlite database to the
** given callback function with the given argument.
*/

func Xsqlite3_busy_timeout ¶

func Xsqlite3_busy_timeout(tls *crt.TLS, _db *Xsqlite3, _ms int32) (r0 int32)

C comment

/*
** This routine installs a default busy handler that waits for the
** specified number of milliseconds before returning 0.
*/

func Xsqlite3_cancel_auto_extension ¶

func Xsqlite3_cancel_auto_extension(tls *crt.TLS, _xInit func(*crt.TLS)) (r0 int32)

C comment

/*
** Cancel a prior call to sqlite3_auto_extension.  Remove xInit from the
** set of routines that is invoked for each new database connection, if it
** is currently on the list.  If xInit is not on the list, then this
** routine is a no-op.
**
** Return 1 if xInit was found on the list and removed.  Return 0 if xInit
** was not on the list.
*/

func Xsqlite3_changes ¶

func Xsqlite3_changes(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Return the number of changes in the most recent call to sqlite3_exec().
*/

func Xsqlite3_clear_bindings ¶

func Xsqlite3_clear_bindings(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Set all the parameters in the compiled SQL statement to NULL.
*/

func Xsqlite3_close ¶

func Xsqlite3_close(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Two variations on the public interface for closing a database
** connection. The sqlite3_close() version returns SQLITE_BUSY and
** leaves the connection option if there are unfinalized prepared
** statements or unfinished sqlite3_backups.  The sqlite3_close_v2()
** version forces the connection to become a zombie if there are
** unclosed resources, and arranges for deallocation when the last
** prepare statement or sqlite3_backup closes.
*/

func Xsqlite3_close_v2 ¶

func Xsqlite3_close_v2(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

func Xsqlite3_collation_needed ¶

func Xsqlite3_collation_needed(tls *crt.TLS, _db *Xsqlite3, _pCollNeededArg unsafe.Pointer, _xCollNeeded func(*crt.TLS, unsafe.Pointer, *Xsqlite3, int32, *int8)) (r0 int32)

C comment

/*
** Register a collation sequence factory callback with the database handle
** db. Replace any previously installed collation sequence factory.
*/

func Xsqlite3_collation_needed16 ¶

func Xsqlite3_collation_needed16(tls *crt.TLS, _db *Xsqlite3, _pCollNeededArg unsafe.Pointer, _xCollNeeded16 func(*crt.TLS, unsafe.Pointer, *Xsqlite3, int32, unsafe.Pointer)) (r0 int32)

C comment

/*
** Register a collation sequence factory callback with the database handle
** db. Replace any previously installed collation sequence factory.
*/

func Xsqlite3_column_blob ¶

func Xsqlite3_column_blob(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 unsafe.Pointer)

C comment

/**************************** sqlite3_column_  *******************************
** The following routines are used to access elements of the current row
** in the result set.
*/

func Xsqlite3_column_bytes ¶

func Xsqlite3_column_bytes(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int32)

func Xsqlite3_column_bytes16 ¶

func Xsqlite3_column_bytes16(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int32)

func Xsqlite3_column_count ¶

func Xsqlite3_column_count(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return the number of columns in the result set for the statement pStmt.
*/

func Xsqlite3_column_decltype ¶

func Xsqlite3_column_decltype(tls *crt.TLS, _pStmt unsafe.Pointer, _N int32) (r0 *int8)

C comment

/*
** Return the column declaration type (if applicable) of the 'i'th column
** of the result set of SQL statement pStmt.
*/

func Xsqlite3_column_decltype16 ¶

func Xsqlite3_column_decltype16(tls *crt.TLS, _pStmt unsafe.Pointer, _N int32) (r0 unsafe.Pointer)

func Xsqlite3_column_double ¶

func Xsqlite3_column_double(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 float64)

func Xsqlite3_column_int ¶

func Xsqlite3_column_int(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int32)

func Xsqlite3_column_int64 ¶

func Xsqlite3_column_int64(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int64)

func Xsqlite3_column_name ¶

func Xsqlite3_column_name(tls *crt.TLS, _pStmt unsafe.Pointer, _N int32) (r0 *int8)

C comment

/*
** Return the name of the Nth column of the result set returned by SQL
** statement pStmt.
*/

func Xsqlite3_column_name16 ¶

func Xsqlite3_column_name16(tls *crt.TLS, _pStmt unsafe.Pointer, _N int32) (r0 unsafe.Pointer)

func Xsqlite3_column_text ¶

func Xsqlite3_column_text(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 *uint8)

func Xsqlite3_column_text16 ¶

func Xsqlite3_column_text16(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 unsafe.Pointer)

func Xsqlite3_column_type ¶

func Xsqlite3_column_type(tls *crt.TLS, _pStmt unsafe.Pointer, _i int32) (r0 int32)

C comment

/* SQLITE_OMIT_UTF16 */

func Xsqlite3_commit_hook ¶

func Xsqlite3_commit_hook(tls *crt.TLS, _db *Xsqlite3, _xCallback func(*crt.TLS, unsafe.Pointer) int32, _pArg unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Register a function to be invoked when a transaction commits.
** If the invoked function returns non-zero, then the commit becomes a
** rollback.
*/

func Xsqlite3_compileoption_get ¶

func Xsqlite3_compileoption_get(tls *crt.TLS, _N int32) (r0 *int8)

C comment

/*
** Return the N-th compile-time option string.  If N is out of range,
** return a NULL pointer.
*/

func Xsqlite3_compileoption_used ¶

func Xsqlite3_compileoption_used(tls *crt.TLS, _zOptName *int8) (r0 int32)

C comment

/*
** Given the name of a compile-time option, return true if that option
** was used and false if not.
**
** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
** is not required for a match.
*/

func Xsqlite3_complete ¶

func Xsqlite3_complete(tls *crt.TLS, _zSql *int8) (r0 int32)

C comment

/*
** Return TRUE if the given SQL string ends in a semicolon.
**
** Special handling is require for CREATE TRIGGER statements.
** Whenever the CREATE TRIGGER keywords are seen, the statement
** must end with ";END;".
**
** This implementation uses a state machine with 8 states:
**
**   (0) INVALID   We have not yet seen a non-whitespace character.
**
**   (1) START     At the beginning or end of an SQL statement.  This routine
**                 returns 1 if it ends in the START state and 0 if it ends
**                 in any other state.
**
**   (2) NORMAL    We are in the middle of statement which ends with a single
**                 semicolon.
**
**   (3) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of
**                 a statement.
**
**   (4) CREATE    The keyword CREATE has been seen at the beginning of a
**                 statement, possibly preceded by EXPLAIN and/or followed by
**                 TEMP or TEMPORARY
**
**   (5) TRIGGER   We are in the middle of a trigger definition that must be
**                 ended by a semicolon, the keyword END, and another semicolon.
**
**   (6) SEMI      We've seen the first semicolon in the ";END;" that occurs at
**                 the end of a trigger definition.
**
**   (7) END       We've seen the ";END" of the ";END;" that occurs at the end
**                 of a trigger definition.
**
** Transitions between states above are determined by tokens extracted
** from the input.  The following tokens are significant:
**
**   (0) tkSEMI      A semicolon.
**   (1) tkWS        Whitespace.
**   (2) tkOTHER     Any other SQL token.
**   (3) tkEXPLAIN   The "explain" keyword.
**   (4) tkCREATE    The "create" keyword.
**   (5) tkTEMP      The "temp" or "temporary" keyword.
**   (6) tkTRIGGER   The "trigger" keyword.
**   (7) tkEND       The "end" keyword.
**
** Whitespace never causes a state transition and is always ignored.
** This means that a SQL string of all whitespace is invalid.
**
** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
** to recognize the end of a trigger can be omitted.  All we have to do
** is look for a semicolon that is not part of an string or comment.
*/

func Xsqlite3_complete16 ¶

func Xsqlite3_complete16(tls *crt.TLS, _zSql unsafe.Pointer) (r0 int32)

C comment

/*
** This routine is the same as the sqlite3_complete() routine described
** above, except that the parameter is required to be UTF-16 encoded, not
** UTF-8.
*/

func Xsqlite3_config ¶

func Xsqlite3_config(tls *crt.TLS, _op int32, args ...interface{}) (r0 int32)

C comment

/*
** This API allows applications to modify the global configuration of
** the SQLite library at run-time.
**
** This routine should only be called when there are no outstanding
** database connections or memory allocations.  This routine is not
** threadsafe.  Failure to heed these warnings can lead to unpredictable
** behavior.
*/

func Xsqlite3_create_collation ¶

func Xsqlite3_create_collation(tls *crt.TLS, _db *Xsqlite3, _zName *int8, _enc int32, _pCtx unsafe.Pointer, _xCompare func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer, int32, unsafe.Pointer) int32) (r0 int32)

C comment

/*
** Register a new collation sequence with the database handle db.
*/

func Xsqlite3_create_collation16 ¶

func Xsqlite3_create_collation16(tls *crt.TLS, _db *Xsqlite3, _zName unsafe.Pointer, _enc int32, _pCtx unsafe.Pointer, _xCompare func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer, int32, unsafe.Pointer) int32) (r0 int32)

C comment

/*
** Register a new collation sequence with the database handle db.
*/

func Xsqlite3_create_collation_v2 ¶

func Xsqlite3_create_collation_v2(tls *crt.TLS, _db *Xsqlite3, _zName *int8, _enc int32, _pCtx unsafe.Pointer, _xCompare func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer, int32, unsafe.Pointer) int32, _xDel func(*crt.TLS, unsafe.Pointer)) (r0 int32)

C comment

/*
** Register a new collation sequence with the database handle db.
*/

func Xsqlite3_create_function ¶

func Xsqlite3_create_function(tls *crt.TLS, _db *Xsqlite3, _zFunc *int8, _nArg int32, _enc int32, _p unsafe.Pointer, _xSFunc func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xStep func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xFinal func(*crt.TLS, *Xsqlite3_context)) (r0 int32)

C comment

/*
** Create new user functions.
*/

func Xsqlite3_create_function16 ¶

func Xsqlite3_create_function16(tls *crt.TLS, _db *Xsqlite3, _zFunctionName unsafe.Pointer, _nArg int32, _eTextRep int32, _p unsafe.Pointer, _xSFunc func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xStep func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xFinal func(*crt.TLS, *Xsqlite3_context)) (r0 int32)

func Xsqlite3_create_function_v2 ¶

func Xsqlite3_create_function_v2(tls *crt.TLS, _db *Xsqlite3, _zFunc *int8, _nArg int32, _enc int32, _p unsafe.Pointer, _xSFunc func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xStep func(*crt.TLS, *Xsqlite3_context, int32, **XMem), _xFinal func(*crt.TLS, *Xsqlite3_context), _xDestroy func(*crt.TLS, unsafe.Pointer)) (r0 int32)

func Xsqlite3_create_module ¶

func Xsqlite3_create_module(tls *crt.TLS, _db *Xsqlite3, _zName *int8, _pModule *Xsqlite3_module, _pAux unsafe.Pointer) (r0 int32)

C comment

/*
** External API function used to create a new virtual-table module.
*/

func Xsqlite3_create_module_v2 ¶

func Xsqlite3_create_module_v2(tls *crt.TLS, _db *Xsqlite3, _zName *int8, _pModule *Xsqlite3_module, _pAux unsafe.Pointer, _xDestroy func(*crt.TLS, unsafe.Pointer)) (r0 int32)

C comment

/*
** External API function used to create a new virtual-table module.
*/

func Xsqlite3_data_count ¶

func Xsqlite3_data_count(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return the number of values available from the current row of the
** currently executing statement pStmt.
*/

func Xsqlite3_db_cacheflush ¶

func Xsqlite3_db_cacheflush(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Flush any dirty pages in the pager-cache for any attached database
** to disk.
*/

func Xsqlite3_db_config ¶

func Xsqlite3_db_config(tls *crt.TLS, _db *Xsqlite3, _op int32, args ...interface{}) (r0 int32)

C comment

/*
** Configuration settings for an individual database connection
*/

func Xsqlite3_db_filename ¶

func Xsqlite3_db_filename(tls *crt.TLS, _db *Xsqlite3, _zDbName *int8) (r0 *int8)

C comment

/*
** Return the filename of the database associated with a database
** connection.
*/

func Xsqlite3_db_readonly ¶

func Xsqlite3_db_readonly(tls *crt.TLS, _db *Xsqlite3, _zDbName *int8) (r0 int32)

C comment

/*
** Return 1 if database is read-only or 0 if read/write.  Return -1 if
** no such database exists.
*/

func Xsqlite3_db_release_memory ¶

func Xsqlite3_db_release_memory(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Free up as much memory as we can from the given database
** connection.
*/

func Xsqlite3_db_status ¶

func Xsqlite3_db_status(tls *crt.TLS, _db *Xsqlite3, _op int32, _pCurrent *int32, _pHighwater *int32, _resetFlag int32) (r0 int32)

C comment

/*
** Query status information for a single database connection
*/

func Xsqlite3_declare_vtab ¶

func Xsqlite3_declare_vtab(tls *crt.TLS, _db *Xsqlite3, _zCreateTable *int8) (r0 int32)

C comment

/*
** This function is used to set the schema of a virtual table.  It is only
** valid to call this function from within the xCreate() or xConnect() of a
** virtual table module.
*/

func Xsqlite3_enable_load_extension ¶

func Xsqlite3_enable_load_extension(tls *crt.TLS, _db *Xsqlite3, _onoff int32) (r0 int32)

C comment

/*
** Enable or disable extension loading.  Extension loading is disabled by
** default so as not to open security holes in older applications.
*/

func Xsqlite3_enable_shared_cache ¶

func Xsqlite3_enable_shared_cache(tls *crt.TLS, _enable int32) (r0 int32)

C comment

/*
** Enable or disable the shared pager and schema features.
**
** This routine has no effect on existing database connections.
** The shared cache setting effects only future calls to
** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
*/

func Xsqlite3_errcode ¶

func Xsqlite3_errcode(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Return the most recent error code generated by an SQLite routine. If NULL is
** passed to this function, we assume a malloc() failed during sqlite3_open().
*/

func Xsqlite3_errmsg ¶

func Xsqlite3_errmsg(tls *crt.TLS, _db *Xsqlite3) (r0 *int8)

C comment

/*
** Return UTF-8 encoded English language explanation of the most recent
** error.
*/

func Xsqlite3_errmsg16 ¶

func Xsqlite3_errmsg16(tls *crt.TLS, _db *Xsqlite3) (r0 unsafe.Pointer)

C comment

/*
** Return UTF-16 encoded English language explanation of the most recent
** error.
*/

func Xsqlite3_errstr ¶

func Xsqlite3_errstr(tls *crt.TLS, _rc int32) (r0 *int8)

C comment

/*
** Return a string that describes the kind of error specified in the
** argument.  For now, this simply calls the internal sqlite3ErrStr()
** function.
*/

func Xsqlite3_exec ¶

func Xsqlite3_exec(tls *crt.TLS, _db *Xsqlite3, _zSql *int8, _xCallback func(*crt.TLS, unsafe.Pointer, int32, **int8, **int8) int32, _pArg unsafe.Pointer, _pzErrMsg **int8) (r0 int32)

C comment

/*
** Execute SQL code.  Return one of the SQLITE_ success/failure
** codes.  Also write an error message into memory obtained from
** malloc() and make *pzErrMsg point to that message.
**
** If the SQL is a query, then for each row in the query result
** the xCallback() function is called.  pArg becomes the first
** argument to xCallback().  If xCallback=NULL then no callback
** is invoked, even for queries.
*/

func Xsqlite3_expanded_sql ¶

func Xsqlite3_expanded_sql(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 *int8)

C comment

/*
** Return the SQL associated with a prepared statement with
** bound parameters expanded.  Space to hold the returned string is
** obtained from sqlite3_malloc().  The caller is responsible for
** freeing the returned string by passing it to sqlite3_free().
**
** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of
** expanded bound parameters.
*/

func Xsqlite3_expired ¶

func Xsqlite3_expired(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return TRUE (non-zero) of the statement supplied as an argument needs
** to be recompiled.  A statement needs to be recompiled whenever the
** execution environment changes in a way that would alter the program
** that sqlite3_prepare() generates.  For example, if new functions or
** collating sequences are registered or if an authorizer function is
** added or changed.
*/

func Xsqlite3_extended_errcode ¶

func Xsqlite3_extended_errcode(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

func Xsqlite3_extended_result_codes ¶

func Xsqlite3_extended_result_codes(tls *crt.TLS, _db *Xsqlite3, _onoff int32) (r0 int32)

C comment

/*
** Enable or disable the extended result codes.
*/

func Xsqlite3_file_control ¶

func Xsqlite3_file_control(tls *crt.TLS, _db *Xsqlite3, _zDbName *int8, _op int32, _pArg unsafe.Pointer) (r0 int32)

C comment

/*
** Invoke the xFileControl method on a particular database.
*/

func Xsqlite3_finalize ¶

func Xsqlite3_finalize(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** The following routine destroys a virtual machine that is created by
** the sqlite3_compile() routine. The integer returned is an SQLITE_
** success/failure code that describes the result of executing the virtual
** machine.
**
** This routine sets the error code and string returned by
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
*/

func Xsqlite3_free ¶

func Xsqlite3_free(tls *crt.TLS, _p unsafe.Pointer)

C comment

/*
** Free memory previously obtained from sqlite3Malloc().
*/

func Xsqlite3_free_table ¶

func Xsqlite3_free_table(tls *crt.TLS, _azResult **int8)

C comment

/*
** This routine frees the space the sqlite3_get_table() malloced.
*/

func Xsqlite3_get_autocommit ¶

func Xsqlite3_get_autocommit(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Test to see whether or not the database connection is in autocommit
** mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on
** by default.  Autocommit is disabled by a BEGIN statement and reenabled
** by the next COMMIT or ROLLBACK.
*/

func Xsqlite3_get_auxdata ¶

func Xsqlite3_get_auxdata(tls *crt.TLS, _pCtx *Xsqlite3_context, _iArg int32) (r0 unsafe.Pointer)

C comment

/*
** Return the auxiliary data pointer, if any, for the iArg'th argument to
** the user-function defined by pCtx.
**
** The left-most argument is 0.
**
** Undocumented behavior:  If iArg is negative then access a cache of
** auxiliary data pointers that is available to all functions within a
** single prepared statement.  The iArg values must match.
*/

func Xsqlite3_get_table ¶

func Xsqlite3_get_table(tls *crt.TLS, _db *Xsqlite3, _zSql *int8, _pazResult ***int8, _pnRow *int32, _pnColumn *int32, _pzErrMsg **int8) (r0 int32)

C comment

/*
** Query the database.  But instead of invoking a callback for each row,
** malloc() for space to hold the result and return the entire results
** at the conclusion of the call.
**
** The result that is written to ***pazResult is held in memory obtained
** from malloc().  But the caller cannot free this memory directly.
** Instead, the entire table should be passed to sqlite3_free_table() when
** the calling procedure is finished using it.
*/

func Xsqlite3_global_recover ¶

func Xsqlite3_global_recover(tls *crt.TLS) (r0 int32)

C comment

/*
** This function is now an anachronism. It used to be used to recover from a
** malloc() failure, but SQLite now does this automatically.
*/

func Xsqlite3_initialize ¶

func Xsqlite3_initialize(tls *crt.TLS) (r0 int32)

C comment

/*
** Initialize SQLite.
**
** This routine must be called to initialize the memory allocation,
** VFS, and mutex subsystems prior to doing any serious work with
** SQLite.  But as long as you do not compile with SQLITE_OMIT_AUTOINIT
** this routine will be called automatically by key routines such as
** sqlite3_open().
**
** This routine is a no-op except on its very first call for the process,
** or for the first call after a call to sqlite3_shutdown.
**
** The first thread to call this routine runs the initialization to
** completion.  If subsequent threads call this routine before the first
** thread has finished the initialization process, then the subsequent
** threads must block until the first thread finishes with the initialization.
**
** The first thread might call this routine recursively.  Recursive
** calls to this routine should not block, of course.  Otherwise the
** initialization process would never complete.
**
** Let X be the first thread to enter this routine.  Let Y be some other
** thread.  Then while the initial invocation of this routine by X is
** incomplete, it is required that:
**
**    *  Calls to this routine from Y must block until the outer-most
**       call by X completes.
**
**    *  Recursive calls to this routine from thread X return immediately
**       without blocking.
*/

func Xsqlite3_interrupt ¶

func Xsqlite3_interrupt(tls *crt.TLS, _db *Xsqlite3)

C comment

/*
** Cause any pending operation to stop at its earliest opportunity.
*/

func Xsqlite3_last_insert_rowid ¶

func Xsqlite3_last_insert_rowid(tls *crt.TLS, _db *Xsqlite3) (r0 int64)

C comment

/*
** Return the ROWID of the most recent insert
*/

func Xsqlite3_libversion ¶

func Xsqlite3_libversion(tls *crt.TLS) (r0 *int8)

C comment

/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
** a pointer to the to the sqlite3_version[] string constant.
*/

func Xsqlite3_libversion_number ¶

func Xsqlite3_libversion_number(tls *crt.TLS) (r0 int32)

C comment

/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
** returns an integer equal to SQLITE_VERSION_NUMBER.
*/

func Xsqlite3_limit ¶

func Xsqlite3_limit(tls *crt.TLS, _db *Xsqlite3, _limitId int32, _newLimit int32) (r0 int32)

C comment

/*
** Change the value of a limit.  Report the old value.
** If an invalid limit index is supplied, report -1.
** Make no changes but still report the old value if the
** new limit is negative.
**
** A new lower limit does not shrink existing constructs.
** It merely prevents new constructs that exceed the limit
** from forming.
*/

func Xsqlite3_load_extension ¶

func Xsqlite3_load_extension(tls *crt.TLS, _db *Xsqlite3, _zFile *int8, _zProc *int8, _pzErrMsg **int8) (r0 int32)

C comment

/*
** CAPI3REF: Load An Extension
** METHOD: sqlite3
**
** ^This interface loads an SQLite extension library from the named file.
**
** ^The sqlite3_load_extension() interface attempts to load an
** [SQLite extension] library contained in the file zFile.  If
** the file cannot be loaded directly, attempts are made to load
** with various operating-system specific extensions added.
** So for example, if "samplelib" cannot be loaded, then names like
** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might
** be tried also.
**
** ^The entry point is zProc.
** ^(zProc may be 0, in which case SQLite will try to come up with an
** entry point name on its own.  It first tries "sqlite3_extension_init".
** If that does not work, it constructs a name "sqlite3_X_init" where the
** X is consists of the lower-case equivalent of all ASCII alphabetic
** characters in the filename from the last "/" to the first following
** "." and omitting any initial "lib".)^
** ^The sqlite3_load_extension() interface returns
** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
** ^If an error occurs and pzErrMsg is not 0, then the
** [sqlite3_load_extension()] interface shall attempt to
** fill *pzErrMsg with error message text stored in memory
** obtained from [sqlite3_malloc()]. The calling function
** should free this memory by calling [sqlite3_free()].
**
** ^Extension loading must be enabled using
** [sqlite3_enable_load_extension()] or
** [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],1,NULL)
** prior to calling this API,
** otherwise an error will be returned.
**
** <b>Security warning:</b> It is recommended that the
** [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method be used to enable only this
** interface.  The use of the [sqlite3_enable_load_extension()] interface
** should be avoided.  This will keep the SQL function [load_extension()]
** disabled and prevent SQL injections from giving attackers
** access to extension loading capabilities.
**
** See also the [load_extension() SQL function].
*/

func Xsqlite3_log ¶

func Xsqlite3_log(tls *crt.TLS, _iErrCode int32, _zFormat *int8, args ...interface{})

C comment

/*
** Format and write a message to the log if logging is enabled.
*/

func Xsqlite3_malloc ¶

func Xsqlite3_malloc(tls *crt.TLS, _n int32) (r0 unsafe.Pointer)

C comment

/*
** This version of the memory allocation is for use by the application.
** First make sure the memory subsystem is initialized, then do the
** allocation.
*/

func Xsqlite3_malloc64 ¶

func Xsqlite3_malloc64(tls *crt.TLS, _n uint64) (r0 unsafe.Pointer)

func Xsqlite3_memory_alarm ¶

func Xsqlite3_memory_alarm(tls *crt.TLS, _xCallback func(*crt.TLS, unsafe.Pointer, int64, int32), _pArg unsafe.Pointer, _iThreshold int64) (r0 int32)

C comment

/*
** Deprecated external interface.  It used to set an alarm callback
** that was invoked when memory usage grew too large.  Now it is a
** no-op.
*/

func Xsqlite3_memory_highwater ¶

func Xsqlite3_memory_highwater(tls *crt.TLS, _resetFlag int32) (r0 int64)

C comment

/*
** Return the maximum amount of memory that has ever been
** checked out since either the beginning of this process
** or since the most recent reset.
*/

func Xsqlite3_memory_used ¶

func Xsqlite3_memory_used(tls *crt.TLS) (r0 int64)

C comment

/*
** Return the amount of memory currently checked out.
*/

func Xsqlite3_mprintf ¶

func Xsqlite3_mprintf(tls *crt.TLS, _zFormat *int8, args ...interface{}) (r0 *int8)

C comment

/*
** Print into memory obtained from sqlite3_malloc()().  Omit the internal
** %-conversion extensions.
*/

func Xsqlite3_msize ¶

func Xsqlite3_msize(tls *crt.TLS, _p unsafe.Pointer) (r0 uint64)

func Xsqlite3_mutex_enter ¶

func Xsqlite3_mutex_enter(tls *crt.TLS, _p *Xsqlite3_mutex)

C comment

/*
** Obtain the mutex p. If some other thread already has the mutex, block
** until it can be obtained.
*/

func Xsqlite3_mutex_free ¶

func Xsqlite3_mutex_free(tls *crt.TLS, _p *Xsqlite3_mutex)

C comment

/*
** Free a dynamic mutex.
*/

func Xsqlite3_mutex_held ¶

func Xsqlite3_mutex_held(tls *crt.TLS, _p *Xsqlite3_mutex) (r0 int32)

C comment

/*
** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
** intended for use inside assert() statements.
*/

func Xsqlite3_mutex_leave ¶

func Xsqlite3_mutex_leave(tls *crt.TLS, _p *Xsqlite3_mutex)

C comment

/*
** The sqlite3_mutex_leave() routine exits a mutex that was previously
** entered by the same thread.  The behavior is undefined if the mutex
** is not currently entered. If a NULL pointer is passed as an argument
** this function is a no-op.
*/

func Xsqlite3_mutex_notheld ¶

func Xsqlite3_mutex_notheld(tls *crt.TLS, _p *Xsqlite3_mutex) (r0 int32)

func Xsqlite3_mutex_try ¶

func Xsqlite3_mutex_try(tls *crt.TLS, _p *Xsqlite3_mutex) (r0 int32)

C comment

/*
** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
*/

func Xsqlite3_next_stmt ¶

func Xsqlite3_next_stmt(tls *crt.TLS, _pDb *Xsqlite3, _pStmt unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Return a pointer to the next prepared statement after pStmt associated
** with database connection pDb.  If pStmt is NULL, return the first
** prepared statement for the database connection.  Return NULL if there
** are no more.
*/

func Xsqlite3_open ¶

func Xsqlite3_open(tls *crt.TLS, _zFilename *int8, _ppDb **Xsqlite3) (r0 int32)

C comment

/*
** Open a new database handle.
*/

func Xsqlite3_open16 ¶

func Xsqlite3_open16(tls *crt.TLS, _zFilename unsafe.Pointer, _ppDb **Xsqlite3) (r0 int32)

C comment

/*
** Open a new database handle.
*/

func Xsqlite3_open_v2 ¶

func Xsqlite3_open_v2(tls *crt.TLS, _filename *int8, _ppDb **Xsqlite3, _flags int32, _zVfs *int8) (r0 int32)

func Xsqlite3_os_end ¶

func Xsqlite3_os_end(tls *crt.TLS) (r0 int32)

C comment

/*
** Shutdown the operating system interface.
**
** Some operating systems might need to do some cleanup in this routine,
** to release dynamically allocated objects.  But not on unix.
** This routine is a no-op for unix.
*/

func Xsqlite3_os_init ¶

func Xsqlite3_os_init(tls *crt.TLS) (r0 int32)

C comment

/*
** Initialize the operating system interface.
**
** This routine registers all VFS implementations for unix-like operating
** systems.  This routine, and the sqlite3_os_end() routine that follows,
** should be the only routines in this file that are visible from other
** files.
**
** This routine is called once during SQLite initialization and by a
** single thread.  The memory allocation and mutex subsystems have not
** necessarily been initialized when this routine is called, and so they
** should not be used.
*/

func Xsqlite3_overload_function ¶

func Xsqlite3_overload_function(tls *crt.TLS, _db *Xsqlite3, _zName *int8, _nArg int32) (r0 int32)

C comment

/*
** Declare that a function has been overloaded by a virtual table.
**
** If the function already exists as a regular global function, then
** this routine is a no-op.  If the function does not exist, then create
** a new one that always throws a run-time error.
**
** When virtual tables intend to provide an overloaded function, they
** should call this routine to make sure the global function exists.
** A global function must exist in order for name resolution to work
** properly.
*/

func Xsqlite3_prepare ¶

func Xsqlite3_prepare(tls *crt.TLS, _db *Xsqlite3, _zSql *int8, _nBytes int32, _ppStmt *unsafe.Pointer, _pzTail **int8) (r0 int32)

C comment

/*
** Two versions of the official API.  Legacy and new use.  In the legacy
** version, the original SQL text is not saved in the prepared statement
** and so if a schema change occurs, SQLITE_SCHEMA is returned by
** sqlite3_step().  In the new version, the original SQL text is retained
** and the statement is automatically recompiled if an schema change
** occurs.
*/

func Xsqlite3_prepare16 ¶

func Xsqlite3_prepare16(tls *crt.TLS, _db *Xsqlite3, _zSql unsafe.Pointer, _nBytes int32, _ppStmt *unsafe.Pointer, _pzTail *unsafe.Pointer) (r0 int32)

C comment

/*
** Two versions of the official API.  Legacy and new use.  In the legacy
** version, the original SQL text is not saved in the prepared statement
** and so if a schema change occurs, SQLITE_SCHEMA is returned by
** sqlite3_step().  In the new version, the original SQL text is retained
** and the statement is automatically recompiled if an schema change
** occurs.
*/

func Xsqlite3_prepare16_v2 ¶

func Xsqlite3_prepare16_v2(tls *crt.TLS, _db *Xsqlite3, _zSql unsafe.Pointer, _nBytes int32, _ppStmt *unsafe.Pointer, _pzTail *unsafe.Pointer) (r0 int32)

func Xsqlite3_prepare_v2 ¶

func Xsqlite3_prepare_v2(tls *crt.TLS, _db *Xsqlite3, _zSql *int8, _nBytes int32, _ppStmt *unsafe.Pointer, _pzTail **int8) (r0 int32)

func Xsqlite3_profile ¶

func Xsqlite3_profile(tls *crt.TLS, _db *Xsqlite3, _xProfile func(*crt.TLS, unsafe.Pointer, *int8, uint64), _pArg unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Register a profile function.  The pArg from the previously registered
** profile function is returned.
**
** A NULL profile function means that no profiling is executes.  A non-NULL
** profile is a pointer to a function that is invoked at the conclusion of
** each SQL statement that is run.
*/

func Xsqlite3_progress_handler ¶

func Xsqlite3_progress_handler(tls *crt.TLS, _db *Xsqlite3, _nOps int32, _xProgress func(*crt.TLS, unsafe.Pointer) int32, _pArg unsafe.Pointer)

C comment

/*
** This routine sets the progress callback for an Sqlite database to the
** given callback function with the given argument. The progress callback will
** be invoked every nOps opcodes.
*/

func Xsqlite3_randomness ¶

func Xsqlite3_randomness(tls *crt.TLS, _N int32, _pBuf unsafe.Pointer)

C comment

/*
** Return N random bytes.
*/

func Xsqlite3_realloc ¶

func Xsqlite3_realloc(tls *crt.TLS, _pOld unsafe.Pointer, _n int32) (r0 unsafe.Pointer)

C comment

/*
** The public interface to sqlite3Realloc.  Make sure that the memory
** subsystem is initialized prior to invoking sqliteRealloc.
*/

func Xsqlite3_realloc64 ¶

func Xsqlite3_realloc64(tls *crt.TLS, _pOld unsafe.Pointer, _n uint64) (r0 unsafe.Pointer)

func Xsqlite3_release_memory ¶

func Xsqlite3_release_memory(tls *crt.TLS, _n int32) (r0 int32)

C comment

/*
** Attempt to release up to n bytes of non-essential memory currently
** held by SQLite. An example of non-essential memory is memory used to
** cache database pages that are not currently in use.
*/

func Xsqlite3_reset ¶

func Xsqlite3_reset(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Terminate the current execution of an SQL statement and reset it
** back to its starting state so that it can be reused. A success code from
** the prior execution is returned.
**
** This routine sets the error code and string returned by
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
*/

func Xsqlite3_reset_auto_extension ¶

func Xsqlite3_reset_auto_extension(tls *crt.TLS)

C comment

/*
** Reset the automatic extension loading mechanism.
*/

func Xsqlite3_result_blob ¶

func Xsqlite3_result_blob(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n int32, _xDel func(*crt.TLS, unsafe.Pointer))

C comment

/*
** CAPI3REF: Setting The Result Of An SQL Function
** METHOD: sqlite3_context
**
** 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(C,N) and sqlite3_result_zeroblob64(C,N)
** interfaces set the result of the application-defined function to be
** a BLOB containing all zero bytes and N bytes in size.
**
** ^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_error_toobig() interface causes SQLite to throw an
** error indicating that a string or BLOB is too long to represent.
**
** ^The sqlite3_result_error_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.
** ^The sqlite3_result_text64() interface sets the return value of an
** application-defined function to be a text string in an encoding
** specified by the fifth (and last) parameter, which must be one
** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE].
** ^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 3rd parameter is non-negative, then it
** must be the byte offset into the string where the NUL terminator would
** appear if the string where NUL terminated.  If any NUL characters occur
** in the string at a byte offset that is less than the value of the 3rd
** parameter, then the resulting string will contain embedded NULs and the
** result of expressions operating on strings with embedded NULs is undefined.
** ^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 to
** 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 content of the parameter nor call a destructor on the content
** 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 of 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.
*/

func Xsqlite3_result_blob64 ¶

func Xsqlite3_result_blob64(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n uint64, _xDel func(*crt.TLS, unsafe.Pointer))

func Xsqlite3_result_double ¶

func Xsqlite3_result_double(tls *crt.TLS, _pCtx *Xsqlite3_context, _rVal float64)

func Xsqlite3_result_error ¶

func Xsqlite3_result_error(tls *crt.TLS, _pCtx *Xsqlite3_context, _z *int8, _n int32)

func Xsqlite3_result_error16 ¶

func Xsqlite3_result_error16(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n int32)

func Xsqlite3_result_error_code ¶

func Xsqlite3_result_error_code(tls *crt.TLS, _pCtx *Xsqlite3_context, _errCode int32)

func Xsqlite3_result_error_nomem ¶

func Xsqlite3_result_error_nomem(tls *crt.TLS, _pCtx *Xsqlite3_context)

C comment

/* An SQLITE_NOMEM error. */

func Xsqlite3_result_error_toobig ¶

func Xsqlite3_result_error_toobig(tls *crt.TLS, _pCtx *Xsqlite3_context)

C comment

/* Force an SQLITE_TOOBIG error. */

func Xsqlite3_result_int ¶

func Xsqlite3_result_int(tls *crt.TLS, _pCtx *Xsqlite3_context, _iVal int32)

func Xsqlite3_result_int64 ¶

func Xsqlite3_result_int64(tls *crt.TLS, _pCtx *Xsqlite3_context, _iVal int64)

func Xsqlite3_result_null ¶

func Xsqlite3_result_null(tls *crt.TLS, _pCtx *Xsqlite3_context)

func Xsqlite3_result_subtype ¶

func Xsqlite3_result_subtype(tls *crt.TLS, _pCtx *Xsqlite3_context, _eSubtype uint32)

C comment

/*
** CAPI3REF: Setting The Subtype Of An SQL Function
** METHOD: sqlite3_context
**
** The sqlite3_result_subtype(C,T) function causes the subtype of
** the result from the [application-defined SQL function] with
** [sqlite3_context] C to be the value T.  Only the lower 8 bits
** of the subtype T are preserved in current versions of SQLite;
** higher order bits are discarded.
** The number of subtype bytes preserved by SQLite might increase
** in future releases of SQLite.
*/

func Xsqlite3_result_text ¶

func Xsqlite3_result_text(tls *crt.TLS, _pCtx *Xsqlite3_context, _z *int8, _n int32, _xDel func(*crt.TLS, unsafe.Pointer))

func Xsqlite3_result_text16 ¶

func Xsqlite3_result_text16(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n int32, _xDel func(*crt.TLS, unsafe.Pointer))

func Xsqlite3_result_text16be ¶

func Xsqlite3_result_text16be(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n int32, _xDel func(*crt.TLS, unsafe.Pointer))

func Xsqlite3_result_text16le ¶

func Xsqlite3_result_text16le(tls *crt.TLS, _pCtx *Xsqlite3_context, _z unsafe.Pointer, _n int32, _xDel func(*crt.TLS, unsafe.Pointer))

func Xsqlite3_result_text64 ¶

func Xsqlite3_result_text64(tls *crt.TLS, _pCtx *Xsqlite3_context, _z *int8, _n uint64, _xDel func(*crt.TLS, unsafe.Pointer), _enc uint8)

func Xsqlite3_result_value ¶

func Xsqlite3_result_value(tls *crt.TLS, _pCtx *Xsqlite3_context, _pValue *XMem)

C comment

/* SQLITE_OMIT_UTF16 */

func Xsqlite3_result_zeroblob ¶

func Xsqlite3_result_zeroblob(tls *crt.TLS, _pCtx *Xsqlite3_context, _n int32)

func Xsqlite3_result_zeroblob64 ¶

func Xsqlite3_result_zeroblob64(tls *crt.TLS, _pCtx *Xsqlite3_context, _n uint64) (r0 int32)

func Xsqlite3_rollback_hook ¶

func Xsqlite3_rollback_hook(tls *crt.TLS, _db *Xsqlite3, _xCallback func(*crt.TLS, unsafe.Pointer), _pArg unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Register a callback to be invoked each time a transaction is rolled
** back by this database connection.
*/

func Xsqlite3_set_authorizer ¶

func Xsqlite3_set_authorizer(tls *crt.TLS, _db *Xsqlite3, _xAuth func(*crt.TLS, unsafe.Pointer, int32, *int8, *int8, *int8, *int8) int32, _pArg unsafe.Pointer) (r0 int32)

C comment

/*
** Set or clear the access authorization function.
**
** The access authorization function is be called during the compilation
** phase to verify that the user has read and/or write access permission on
** various fields of the database.  The first argument to the auth function
** is a copy of the 3rd argument to this routine.  The second argument
** to the auth function is one of these constants:
**
**       SQLITE_CREATE_INDEX
**       SQLITE_CREATE_TABLE
**       SQLITE_CREATE_TEMP_INDEX
**       SQLITE_CREATE_TEMP_TABLE
**       SQLITE_CREATE_TEMP_TRIGGER
**       SQLITE_CREATE_TEMP_VIEW
**       SQLITE_CREATE_TRIGGER
**       SQLITE_CREATE_VIEW
**       SQLITE_DELETE
**       SQLITE_DROP_INDEX
**       SQLITE_DROP_TABLE
**       SQLITE_DROP_TEMP_INDEX
**       SQLITE_DROP_TEMP_TABLE
**       SQLITE_DROP_TEMP_TRIGGER
**       SQLITE_DROP_TEMP_VIEW
**       SQLITE_DROP_TRIGGER
**       SQLITE_DROP_VIEW
**       SQLITE_INSERT
**       SQLITE_PRAGMA
**       SQLITE_READ
**       SQLITE_SELECT
**       SQLITE_TRANSACTION
**       SQLITE_UPDATE
**
** The third and fourth arguments to the auth function are the name of
** the table and the column that are being accessed.  The auth function
** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE.  If
** SQLITE_OK is returned, it means that access is allowed.  SQLITE_DENY
** means that the SQL statement will never-run - the sqlite3_exec() call
** will return with an error.  SQLITE_IGNORE means that the SQL statement
** should run but attempts to read the specified column will return NULL
** and attempts to write the column will be ignored.
**
** Setting the auth function to NULL disables this hook.  The default
** setting of the auth function is NULL.
*/

func Xsqlite3_set_auxdata ¶

func Xsqlite3_set_auxdata(tls *crt.TLS, _pCtx *Xsqlite3_context, _iArg int32, _pAux unsafe.Pointer, _xDelete func(*crt.TLS, unsafe.Pointer))

C comment

/*
** Set the auxiliary data pointer and delete function, for the iArg'th
** argument to the user-function defined by pCtx. Any previous value is
** deleted by calling the delete function specified when it was set.
**
** The left-most argument is 0.
**
** Undocumented behavior:  If iArg is negative then make the data available
** to all functions within the current prepared statement using iArg as an
** access code.
*/

func Xsqlite3_set_last_insert_rowid ¶

func Xsqlite3_set_last_insert_rowid(tls *crt.TLS, _db *Xsqlite3, _iRowid int64)

C comment

/*
** Set the value returned by the sqlite3_last_insert_rowid() API function.
*/

func Xsqlite3_shutdown ¶

func Xsqlite3_shutdown(tls *crt.TLS) (r0 int32)

C comment

/*
** Undo the effects of sqlite3_initialize().  Must not be called while
** there are outstanding database connections or memory allocations or
** while any part of SQLite is otherwise in use in any thread.  This
** routine is not threadsafe.  But it is safe to invoke this routine
** on when SQLite is already shut down.  If SQLite is already shut down
** when this routine is invoked, then this routine is a harmless no-op.
*/

func Xsqlite3_sleep ¶

func Xsqlite3_sleep(tls *crt.TLS, _ms int32) (r0 int32)

C comment

/*
** Sleep for a little while.  Return the amount of time slept.
*/

func Xsqlite3_snprintf ¶

func Xsqlite3_snprintf(tls *crt.TLS, _n int32, _zBuf *int8, _zFormat *int8, args ...interface{}) (r0 *int8)

func Xsqlite3_soft_heap_limit ¶

func Xsqlite3_soft_heap_limit(tls *crt.TLS, _n int32)

C comment

/*
** CAPI3REF: Deprecated Soft Heap Limit Interface
** DEPRECATED
**
** This is a deprecated version of the [sqlite3_soft_heap_limit64()]
** interface.  This routine is provided for historical compatibility
** only.  All new applications should use the
** [sqlite3_soft_heap_limit64()] interface rather than this one.
*/

func Xsqlite3_soft_heap_limit64 ¶

func Xsqlite3_soft_heap_limit64(tls *crt.TLS, _n int64) (r0 int64)

C comment

/*
** Set the soft heap-size limit for the library. Passing a zero or
** negative value indicates no limit.
*/

func Xsqlite3_sourceid ¶

func Xsqlite3_sourceid(tls *crt.TLS) (r0 *int8)

C comment

/* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a
** pointer to a string constant whose value is the same as the
** SQLITE_SOURCE_ID C preprocessor macro.
*/

func Xsqlite3_sql ¶

func Xsqlite3_sql(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 *int8)

C comment

/*
** Return the SQL associated with a prepared statement
*/

func Xsqlite3_status ¶

func Xsqlite3_status(tls *crt.TLS, _op int32, _pCurrent *int32, _pHighwater *int32, _resetFlag int32) (r0 int32)

C comment

/*
** CAPI3REF: SQLite Runtime Status
**
** ^These interfaces are used to retrieve runtime status information
** about the performance of SQLite, and optionally to reset various
** highwater marks.  ^The first argument is an integer code for
** the specific parameter to measure.  ^(Recognized integer codes
** are of the form [status parameters | SQLITE_STATUS_...].)^
** ^The current value of the parameter is returned into *pCurrent.
** ^The highest recorded value is returned in *pHighwater.  ^If the
** resetFlag is true, then the highest record value is reset after
** *pHighwater is written.  ^(Some parameters do not record the highest
** value.  For those parameters
** nothing is written into *pHighwater and the resetFlag is ignored.)^
** ^(Other parameters record only the highwater mark and not the current
** value.  For these latter parameters nothing is written into *pCurrent.)^
**
** ^The sqlite3_status() and sqlite3_status64() routines return
** SQLITE_OK on success and a non-zero [error code] on failure.
**
** If either the current value or the highwater mark is too large to
** be represented by a 32-bit integer, then the values returned by
** sqlite3_status() are undefined.
**
** See also: [sqlite3_db_status()]
*/

func Xsqlite3_status64 ¶

func Xsqlite3_status64(tls *crt.TLS, _op int32, _pCurrent *int64, _pHighwater *int64, _resetFlag int32) (r0 int32)

C comment

/*
** Query status information.
*/

func Xsqlite3_step ¶

func Xsqlite3_step(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** This is the top-level implementation of sqlite3_step().  Call
** sqlite3Step() to do most of the work.  If a schema error occurs,
** call sqlite3Reprepare() and try again.
*/

func Xsqlite3_stmt_busy ¶

func Xsqlite3_stmt_busy(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return true if the prepared statement is in need of being reset.
*/

func Xsqlite3_stmt_readonly ¶

func Xsqlite3_stmt_readonly(tls *crt.TLS, _pStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Return true if the prepared statement is guaranteed to not modify the
** database.
*/

func Xsqlite3_stmt_status ¶

func Xsqlite3_stmt_status(tls *crt.TLS, _pStmt unsafe.Pointer, _op int32, _resetFlag int32) (r0 int32)

C comment

/*
** Return the value of a status counter for a prepared statement
*/

func Xsqlite3_strglob ¶

func Xsqlite3_strglob(tls *crt.TLS, _zGlobPattern *int8, _zString *int8) (r0 int32)

C comment

/*
** The sqlite3_strglob() interface.  Return 0 on a match (like strcmp()) and
** non-zero if there is no match.
*/

func Xsqlite3_stricmp ¶

func Xsqlite3_stricmp(tls *crt.TLS, _zLeft *int8, _zRight *int8) (r0 int32)

C comment

/*
** Some systems have stricmp().  Others have strcasecmp().  Because
** there is no consistency, we will define our own.
**
** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
** sqlite3_strnicmp() APIs allow applications and extensions to compare
** the contents of two buffers containing UTF-8 strings in a
** case-independent fashion, using the same definition of "case
** independence" that SQLite uses internally when comparing identifiers.
*/

func Xsqlite3_strlike ¶

func Xsqlite3_strlike(tls *crt.TLS, _zPattern *int8, _zStr *int8, _esc uint32) (r0 int32)

C comment

/*
** The sqlite3_strlike() interface.  Return 0 on a match and non-zero for
** a miss - like strcmp().
*/

func Xsqlite3_strnicmp ¶

func Xsqlite3_strnicmp(tls *crt.TLS, _zLeft *int8, _zRight *int8, _N int32) (r0 int32)

func Xsqlite3_system_errno ¶

func Xsqlite3_system_errno(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** CAPI3REF: Low-level system error code
**
** ^Attempt to return the underlying operating system error code or error
** number that caused the most recent I/O error or failure to open a file.
** The return value is OS-dependent.  For example, on unix systems, after
** [sqlite3_open_v2()] returns [SQLITE_CANTOPEN], this interface could be
** called to get back the underlying "errno" that caused the problem, such
** as ENOSPC, EAUTH, EISDIR, and so forth.
*/

func Xsqlite3_table_column_metadata ¶

func Xsqlite3_table_column_metadata(tls *crt.TLS, _db *Xsqlite3, _zDbName *int8, _zTableName *int8, _zColumnName *int8, _pzDataType **int8, _pzCollSeq **int8, _pNotNull *int32, _pPrimaryKey *int32, _pAutoinc *int32) (r0 int32)

C comment

/*
** Return meta information about a specific column of a database table.
** See comment in sqlite3.h (sqlite.h.in) for details.
*/

func Xsqlite3_test_control ¶

func Xsqlite3_test_control(tls *crt.TLS, _op int32, args ...interface{}) (r0 int32)

C comment

/*
** Interface to the testing logic.
*/

func Xsqlite3_thread_cleanup ¶

func Xsqlite3_thread_cleanup(tls *crt.TLS)

C comment

/*
** This is a convenience routine that makes sure that all thread-specific
** data for this thread has been deallocated.
**
** SQLite no longer uses thread-specific data so this routine is now a
** no-op.  It is retained for historical compatibility.
*/

func Xsqlite3_threadsafe ¶

func Xsqlite3_threadsafe(tls *crt.TLS) (r0 int32)

C comment

/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
** zero if and only if SQLite was compiled with mutexing code omitted due to
** the SQLITE_THREADSAFE compile-time option being set to 0.
*/

func Xsqlite3_total_changes ¶

func Xsqlite3_total_changes(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Return the number of changes since the database handle was opened.
*/

func Xsqlite3_trace ¶

func Xsqlite3_trace(tls *crt.TLS, _db *Xsqlite3, _xTrace func(*crt.TLS, unsafe.Pointer, *int8), _pArg unsafe.Pointer) (r0 unsafe.Pointer)

func Xsqlite3_trace_v2 ¶

func Xsqlite3_trace_v2(tls *crt.TLS, _db *Xsqlite3, _mTrace uint32, _xTrace func(*crt.TLS, uint32, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer) int32, _pArg unsafe.Pointer) (r0 int32)

C comment

/* Register a trace callback using the version-2 interface.
*/

func Xsqlite3_transfer_bindings ¶

func Xsqlite3_transfer_bindings(tls *crt.TLS, _pFromStmt unsafe.Pointer, _pToStmt unsafe.Pointer) (r0 int32)

C comment

/*
** Deprecated external interface.  Internal/core SQLite code
** should call sqlite3TransferBindings.
**
** It is misuse to call this routine with statements from different
** database connections.  But as this is a deprecated interface, we
** will not bother to check for that condition.
**
** If the two statements contain a different number of bindings, then
** an SQLITE_ERROR is returned.  Nothing else can go wrong, so otherwise
** SQLITE_OK is returned.
*/

func Xsqlite3_update_hook ¶

func Xsqlite3_update_hook(tls *crt.TLS, _db *Xsqlite3, _xCallback func(*crt.TLS, unsafe.Pointer, int32, *int8, *int8, int64), _pArg unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Register a callback to be invoked each time a row is updated,
** inserted or deleted using this database connection.
*/

func Xsqlite3_uri_boolean ¶

func Xsqlite3_uri_boolean(tls *crt.TLS, _zFilename *int8, _zParam *int8, _bDflt int32) (r0 int32)

C comment

/*
** Return a boolean value for a query parameter.
*/

func Xsqlite3_uri_int64 ¶

func Xsqlite3_uri_int64(tls *crt.TLS, _zFilename *int8, _zParam *int8, _bDflt int64) (r0 int64)

C comment

/*
** Return a 64-bit integer value for a query parameter.
*/

func Xsqlite3_uri_parameter ¶

func Xsqlite3_uri_parameter(tls *crt.TLS, _zFilename *int8, _zParam *int8) (r0 *int8)

C comment

/*
** This is a utility routine, useful to VFS implementations, that checks
** to see if a database file was a URI that contained a specific query
** parameter, and if so obtains the value of the query parameter.
**
** The zFilename argument is the filename pointer passed into the xOpen()
** method of a VFS implementation.  The zParam argument is the name of the
** query parameter we seek.  This routine returns the value of the zParam
** parameter if it exists.  If the parameter does not exist, this routine
** returns a NULL pointer.
*/

func Xsqlite3_user_data ¶

func Xsqlite3_user_data(tls *crt.TLS, _p *Xsqlite3_context) (r0 unsafe.Pointer)

C comment

/*
** Extract the user data from a sqlite3_context structure and return a
** pointer to it.
*/

func Xsqlite3_value_blob ¶

func Xsqlite3_value_blob(tls *crt.TLS, _pVal *XMem) (r0 unsafe.Pointer)

C comment

/**************************** sqlite3_value_  *******************************
** The following routines extract information from a Mem or sqlite3_value
** structure.
*/

func Xsqlite3_value_bytes ¶

func Xsqlite3_value_bytes(tls *crt.TLS, _pVal *XMem) (r0 int32)

func Xsqlite3_value_bytes16 ¶

func Xsqlite3_value_bytes16(tls *crt.TLS, _pVal *XMem) (r0 int32)

func Xsqlite3_value_double ¶

func Xsqlite3_value_double(tls *crt.TLS, _pVal *XMem) (r0 float64)

func Xsqlite3_value_free ¶

func Xsqlite3_value_free(tls *crt.TLS, _pOld *XMem)

C comment

/* Destroy an sqlite3_value object previously obtained from
** sqlite3_value_dup().
*/

func Xsqlite3_value_int ¶

func Xsqlite3_value_int(tls *crt.TLS, _pVal *XMem) (r0 int32)

func Xsqlite3_value_int64 ¶

func Xsqlite3_value_int64(tls *crt.TLS, _pVal *XMem) (r0 int64)

func Xsqlite3_value_numeric_type ¶

func Xsqlite3_value_numeric_type(tls *crt.TLS, _pVal *XMem) (r0 int32)

C comment

/*
** Try to convert the type of a function argument or a result column
** into a numeric representation.  Use either INTEGER or REAL whichever
** is appropriate.  But only do the conversion if it is possible without
** loss of information and return the revised type of the argument.
*/

func Xsqlite3_value_subtype ¶

func Xsqlite3_value_subtype(tls *crt.TLS, _pVal *XMem) (r0 uint32)

C comment

/*
** CAPI3REF: Finding The Subtype Of SQL Values
** METHOD: sqlite3_value
**
** The sqlite3_value_subtype(V) function returns the subtype for
** an [application-defined SQL function] argument V.  The subtype
** information can be used to pass a limited amount of context from
** one SQL function to another.  Use the [sqlite3_result_subtype()]
** routine to set the subtype for the return value of an SQL function.
**
** SQLite makes no use of subtype itself.  It merely passes the subtype
** from the result of one [application-defined SQL function] into the
** input of another.
*/

func Xsqlite3_value_text ¶

func Xsqlite3_value_text(tls *crt.TLS, _pVal *XMem) (r0 *uint8)

func Xsqlite3_value_text16 ¶

func Xsqlite3_value_text16(tls *crt.TLS, _pVal *XMem) (r0 unsafe.Pointer)

func Xsqlite3_value_text16be ¶

func Xsqlite3_value_text16be(tls *crt.TLS, _pVal *XMem) (r0 unsafe.Pointer)

func Xsqlite3_value_text16le ¶

func Xsqlite3_value_text16le(tls *crt.TLS, _pVal *XMem) (r0 unsafe.Pointer)

func Xsqlite3_value_type ¶

func Xsqlite3_value_type(tls *crt.TLS, _pVal *XMem) (r0 int32)

C comment

/* SQLITE_OMIT_UTF16 */
/* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
** point number string BLOB NULL
*/

func Xsqlite3_vfs_register ¶

func Xsqlite3_vfs_register(tls *crt.TLS, _pVfs *Xsqlite3_vfs, _makeDflt int32) (r0 int32)

C comment

/*
** Register a VFS with the system.  It is harmless to register the same
** VFS multiple times.  The new VFS becomes the default if makeDflt is
** true.
*/

func Xsqlite3_vfs_unregister ¶

func Xsqlite3_vfs_unregister(tls *crt.TLS, _pVfs *Xsqlite3_vfs) (r0 int32)

C comment

/*
** Unregister a VFS so that it is no longer accessible.
*/

func Xsqlite3_vmprintf ¶

func Xsqlite3_vmprintf(tls *crt.TLS, _zFormat *int8, _ap []interface{}) (r0 *int8)

C comment

/*
** Print into memory obtained from sqlite3_malloc().  Omit the internal
** %-conversion extensions.
*/

func Xsqlite3_vsnprintf ¶

func Xsqlite3_vsnprintf(tls *crt.TLS, _n int32, _zBuf *int8, _zFormat *int8, _ap []interface{}) (r0 *int8)

C comment

/*
** sqlite3_snprintf() works like snprintf() except that it ignores the
** current locale settings.  This is important for SQLite because we
** are not able to use a "," as the decimal point in place of "." as
** specified by some locales.
**
** Oops:  The first two arguments of sqlite3_snprintf() are backwards
** from the snprintf() standard.  Unfortunately, it is too late to change
** this without breaking compatibility, so we just have to live with the
** mistake.
**
** sqlite3_vsnprintf() is the varargs version.
*/

func Xsqlite3_vtab_config ¶

func Xsqlite3_vtab_config(tls *crt.TLS, _db *Xsqlite3, _op int32, args ...interface{}) (r0 int32)

C comment

/*
** Call from within the xCreate() or xConnect() methods to provide
** the SQLite core with additional information about the behavior
** of the virtual table being implemented.
*/

func Xsqlite3_vtab_on_conflict ¶

func Xsqlite3_vtab_on_conflict(tls *crt.TLS, _db *Xsqlite3) (r0 int32)

C comment

/*
** Return the ON CONFLICT resolution mode in effect for the virtual
** table update operation currently in progress.
**
** The results of this routine are undefined unless it is called from
** within an xUpdate method.
*/

func Xsqlite3_wal_autocheckpoint ¶

func Xsqlite3_wal_autocheckpoint(tls *crt.TLS, _db *Xsqlite3, _nFrame int32) (r0 int32)

C comment

/*
** Configure an sqlite3_wal_hook() callback to automatically checkpoint
** a database after committing a transaction if there are nFrame or
** more frames in the log file. Passing zero or a negative value as the
** nFrame parameter disables automatic checkpoints entirely.
**
** The callback registered by this function replaces any existing callback
** registered using sqlite3_wal_hook(). Likewise, registering a callback
** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
** configured by this function.
*/

func Xsqlite3_wal_checkpoint ¶

func Xsqlite3_wal_checkpoint(tls *crt.TLS, _db *Xsqlite3, _zDb *int8) (r0 int32)

C comment

/*
** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
** to contains a zero-length string, all attached databases are
** checkpointed.
*/

func Xsqlite3_wal_checkpoint_v2 ¶

func Xsqlite3_wal_checkpoint_v2(tls *crt.TLS, _db *Xsqlite3, _zDb *int8, _eMode int32, _pnLog *int32, _pnCkpt *int32) (r0 int32)

C comment

/*
** Checkpoint database zDb.
*/

func Xsqlite3_wal_hook ¶

func Xsqlite3_wal_hook(tls *crt.TLS, _db *Xsqlite3, _xCallback func(*crt.TLS, unsafe.Pointer, *Xsqlite3, *int8, int32) int32, _pArg unsafe.Pointer) (r0 unsafe.Pointer)

C comment

/*
** Register a callback to be invoked each time a transaction is written
** into the write-ahead-log by this database connection.
*/