sqlite3

Documentation

Index

• Constants
• Variables
• func PatchIssue199()
• func X__ccgo_sqlite3_log(t *libc.TLS, iErrCode int32, zFormat uintptr, va uintptr)
• func Xsqlite3_aggregate_context(tls *libc.TLS, p uintptr, nByte int32) (r uintptr)
• func Xsqlite3_aggregate_count(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_auto_extension(tls *libc.TLS, xInit uintptr) (r int32)
• func Xsqlite3_autovacuum_pages(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr, ...) (r int32)
• func Xsqlite3_backup_finish(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_backup_init(tls *libc.TLS, pDestDb uintptr, zDestDb uintptr, pSrcDb uintptr, ...) (r uintptr)
• func Xsqlite3_backup_pagecount(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_backup_remaining(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_backup_step(tls *libc.TLS, p uintptr, nPage int32) (r int32)
• func Xsqlite3_bind_blob(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData int32, ...) (r int32)
• func Xsqlite3_bind_blob64(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData Tsqlite3_uint64, ...) (r int32)
• func Xsqlite3_bind_double(tls *libc.TLS, pStmt uintptr, i int32, rValue float64) (r int32)
• func Xsqlite3_bind_int(tls *libc.TLS, p uintptr, i int32, iValue int32) (r int32)
• func Xsqlite3_bind_int64(tls *libc.TLS, pStmt uintptr, i int32, iValue Tsqlite_int64) (r int32)
• func Xsqlite3_bind_null(tls *libc.TLS, pStmt uintptr, i int32) (r int32)
• func Xsqlite3_bind_parameter_count(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_bind_parameter_index(tls *libc.TLS, pStmt uintptr, zName uintptr) (r int32)
• func Xsqlite3_bind_parameter_name(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)
• func Xsqlite3_bind_pointer(tls *libc.TLS, pStmt uintptr, i int32, pPtr uintptr, zPTtype uintptr, ...) (r int32)
• func Xsqlite3_bind_text(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData int32, ...) (r int32)
• func Xsqlite3_bind_text16(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, n int32, xDel uintptr) (r int32)
• func Xsqlite3_bind_text64(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData Tsqlite3_uint64, ...) (r int32)
• func Xsqlite3_bind_value(tls *libc.TLS, pStmt uintptr, i int32, pValue uintptr) (r int32)
• func Xsqlite3_bind_zeroblob(tls *libc.TLS, pStmt uintptr, i int32, n int32) (r int32)
• func Xsqlite3_bind_zeroblob64(tls *libc.TLS, pStmt uintptr, i int32, n Tsqlite3_uint64) (r int32)
• func Xsqlite3_blob_bytes(tls *libc.TLS, pBlob uintptr) (r int32)
• func Xsqlite3_blob_close(tls *libc.TLS, pBlob uintptr) (r int32)
• func Xsqlite3_blob_open(tls *libc.TLS, db uintptr, zDb uintptr, zTable uintptr, zColumn uintptr, ...) (r int32)
• func Xsqlite3_blob_read(tls *libc.TLS, pBlob uintptr, z uintptr, n int32, iOffset int32) (r int32)
• func Xsqlite3_blob_reopen(tls *libc.TLS, pBlob uintptr, iRow Tsqlite3_int64) (r int32)
• func Xsqlite3_blob_write(tls *libc.TLS, pBlob uintptr, z uintptr, n int32, iOffset int32) (r int32)
• func Xsqlite3_busy_handler(tls *libc.TLS, db uintptr, xBusy uintptr, pArg uintptr) (r int32)
• func Xsqlite3_busy_timeout(tls *libc.TLS, db uintptr, ms int32) (r int32)
• func Xsqlite3_cancel_auto_extension(tls *libc.TLS, xInit uintptr) (r int32)
• func Xsqlite3_changes(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_clear_bindings(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_close(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_close_v2(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_collation_needed(tls *libc.TLS, db uintptr, pCollNeededArg uintptr, xCollNeeded uintptr) (r int32)
• func Xsqlite3_collation_needed16(tls *libc.TLS, db uintptr, pCollNeededArg uintptr, xCollNeeded16 uintptr) (r int32)
• func Xsqlite3_column_blob(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)
• func Xsqlite3_column_bytes(tls *libc.TLS, pStmt uintptr, i int32) (r int32)
• func Xsqlite3_column_bytes16(tls *libc.TLS, pStmt uintptr, i int32) (r int32)
• func Xsqlite3_column_count(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_column_database_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_database_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_decltype(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_decltype16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_double(tls *libc.TLS, pStmt uintptr, i int32) (r float64)
• func Xsqlite3_column_int(tls *libc.TLS, pStmt uintptr, i int32) (r int32)
• func Xsqlite3_column_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_origin_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_origin_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_table_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_table_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)
• func Xsqlite3_column_text(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)
• func Xsqlite3_column_text16(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)
• func Xsqlite3_column_type(tls *libc.TLS, pStmt uintptr, i int32) (r int32)
• func Xsqlite3_column_value(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)
• func Xsqlite3_commit_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_compileoption_get(tls *libc.TLS, N int32) (r uintptr)
• func Xsqlite3_compileoption_used(tls *libc.TLS, zOptName uintptr) (r int32)
• func Xsqlite3_complete(tls *libc.TLS, zSql uintptr) (r int32)
• func Xsqlite3_complete16(tls *libc.TLS, zSql uintptr) (r int32)
• func Xsqlite3_config(tls *libc.TLS, op int32, va uintptr) (r int32)
• func Xsqlite3_context_db_handle(tls *libc.TLS, p uintptr) (r uintptr)
• func Xsqlite3_create_collation(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, ...) (r int32)
• func Xsqlite3_create_collation16(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, ...) (r int32)
• func Xsqlite3_create_collation_v2(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, ...) (r int32)
• func Xsqlite3_create_filename(tls *libc.TLS, zDatabase uintptr, zJournal uintptr, zWal uintptr, nParam int32, ...) (r uintptr)
• func Xsqlite3_create_function(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, ...) (r int32)
• func Xsqlite3_create_function16(tls *libc.TLS, db uintptr, zFunctionName uintptr, nArg int32, eTextRep int32, ...) (r int32)
• func Xsqlite3_create_function_v2(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, ...) (r int32)
• func Xsqlite3_create_module(tls *libc.TLS, db uintptr, zName uintptr, pModule uintptr, pAux uintptr) (r int32)
• func Xsqlite3_create_module_v2(tls *libc.TLS, db uintptr, zName uintptr, pModule uintptr, pAux uintptr, ...) (r int32)
• func Xsqlite3_create_window_function(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, ...) (r int32)
• func Xsqlite3_data_count(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_database_file_object(tls *libc.TLS, zName uintptr) (r uintptr)
• func Xsqlite3_db_cacheflush(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_db_config(tls *libc.TLS, db uintptr, op int32, va uintptr) (r int32)
• func Xsqlite3_db_filename(tls *libc.TLS, db uintptr, zDbName uintptr) (r uintptr)
• func Xsqlite3_db_handle(tls *libc.TLS, pStmt uintptr) (r uintptr)
• func Xsqlite3_db_mutex(tls *libc.TLS, db uintptr) (r uintptr)
• func Xsqlite3_db_name(tls *libc.TLS, db uintptr, N int32) (r uintptr)
• func Xsqlite3_db_readonly(tls *libc.TLS, db uintptr, zDbName uintptr) (r int32)
• func Xsqlite3_db_release_memory(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_db_status(tls *libc.TLS, db uintptr, op int32, pCurrent uintptr, pHighwater uintptr, ...) (r int32)
• func Xsqlite3_declare_vtab(tls *libc.TLS, db uintptr, zCreateTable uintptr) (r int32)
• func Xsqlite3_deserialize(tls *libc.TLS, db uintptr, zSchema uintptr, pData uintptr, szDb Tsqlite3_int64, ...) (r int32)
• func Xsqlite3_drop_modules(tls *libc.TLS, db uintptr, azNames uintptr) (r int32)
• func Xsqlite3_enable_load_extension(tls *libc.TLS, db uintptr, onoff int32) (r int32)
• func Xsqlite3_enable_shared_cache(tls *libc.TLS, enable int32) (r int32)
• func Xsqlite3_errcode(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_errmsg(tls *libc.TLS, db uintptr) (r uintptr)
• func Xsqlite3_errmsg16(tls *libc.TLS, db uintptr) (r uintptr)
• func Xsqlite3_error_offset(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_errstr(tls *libc.TLS, rc int32) (r uintptr)
• func Xsqlite3_exec(tls *libc.TLS, db uintptr, zSql uintptr, xCallback Tsqlite3_callback, ...) (r int32)
• func Xsqlite3_expanded_sql(tls *libc.TLS, pStmt uintptr) (r uintptr)
• func Xsqlite3_expired(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_extended_errcode(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_extended_result_codes(tls *libc.TLS, db uintptr, onoff int32) (r int32)
• func Xsqlite3_file_control(tls *libc.TLS, db uintptr, zDbName uintptr, op int32, pArg uintptr) (r int32)
• func Xsqlite3_filename_database(tls *libc.TLS, zFilename uintptr) (r uintptr)
• func Xsqlite3_filename_journal(tls *libc.TLS, zFilename uintptr) (r uintptr)
• func Xsqlite3_filename_wal(tls *libc.TLS, zFilename uintptr) (r uintptr)
• func Xsqlite3_finalize(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_free(tls *libc.TLS, p uintptr)
• func Xsqlite3_free_filename(tls *libc.TLS, p uintptr)
• func Xsqlite3_free_table(tls *libc.TLS, azResult uintptr)
• func Xsqlite3_get_autocommit(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_get_auxdata(tls *libc.TLS, pCtx uintptr, iArg int32) (r uintptr)
• func Xsqlite3_get_clientdata(tls *libc.TLS, db uintptr, zName uintptr) (r uintptr)
• func Xsqlite3_get_table(tls *libc.TLS, db uintptr, zSql uintptr, pazResult uintptr, pnRow uintptr, ...) (r int32)
• func Xsqlite3_global_recover(tls *libc.TLS) (r int32)
• func Xsqlite3_initialize(tls *libc.TLS) (r int32)
• func Xsqlite3_interrupt(tls *libc.TLS, db uintptr)
• func Xsqlite3_is_interrupted(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_keyword_check(tls *libc.TLS, zName uintptr, nName int32) (r int32)
• func Xsqlite3_keyword_count(tls *libc.TLS) (r int32)
• func Xsqlite3_keyword_name(tls *libc.TLS, i int32, pzName uintptr, pnName uintptr) (r int32)
• func Xsqlite3_libversion(tls *libc.TLS) (r uintptr)
• func Xsqlite3_libversion_number(tls *libc.TLS) (r int32)
• func Xsqlite3_limit(tls *libc.TLS, db uintptr, limitId int32, newLimit int32) (r int32)
• func Xsqlite3_load_extension(tls *libc.TLS, db uintptr, zFile uintptr, zProc uintptr, pzErrMsg uintptr) (r int32)
• func Xsqlite3_log(tls *libc.TLS, iErrCode int32, zFormat uintptr, va uintptr)
• func Xsqlite3_malloc(tls *libc.TLS, n int32) (r uintptr)
• func Xsqlite3_malloc64(tls *libc.TLS, n Tsqlite3_uint64) (r uintptr)
• func Xsqlite3_memory_alarm(tls *libc.TLS, xCallback uintptr, pArg uintptr, iThreshold Tsqlite3_int64) (r int32)
• func Xsqlite3_mprintf(tls *libc.TLS, zFormat uintptr, va uintptr) (r uintptr)
• func Xsqlite3_mutex_alloc(tls *libc.TLS, id int32) (r uintptr)
• func Xsqlite3_mutex_enter(tls *libc.TLS, p uintptr)
• func Xsqlite3_mutex_free(tls *libc.TLS, p uintptr)
• func Xsqlite3_mutex_leave(tls *libc.TLS, p uintptr)
• func Xsqlite3_mutex_try(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_next_stmt(tls *libc.TLS, pDb uintptr, pStmt uintptr) (r uintptr)
• func Xsqlite3_open(tls *libc.TLS, zFilename uintptr, ppDb uintptr) (r int32)
• func Xsqlite3_open16(tls *libc.TLS, zFilename uintptr, ppDb uintptr) (r int32)
• func Xsqlite3_open_v2(tls *libc.TLS, filename uintptr, ppDb uintptr, flags int32, zVfs uintptr) (r int32)
• func Xsqlite3_os_end(tls *libc.TLS) (r int32)
• func Xsqlite3_os_init(tls *libc.TLS) (r int32)
• func Xsqlite3_overload_function(tls *libc.TLS, db uintptr, zName uintptr, nArg int32) (r int32)
• func Xsqlite3_prepare(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, ...) (r int32)
• func Xsqlite3_prepare16(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, ...) (r int32)
• func Xsqlite3_prepare16_v2(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, ...) (r int32)
• func Xsqlite3_prepare16_v3(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, prepFlags uint32, ...) (r int32)
• func Xsqlite3_prepare_v2(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, ...) (r int32)
• func Xsqlite3_prepare_v3(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, prepFlags uint32, ...) (r int32)
• func Xsqlite3_preupdate_blobwrite(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_preupdate_count(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_preupdate_depth(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_preupdate_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_preupdate_new(tls *libc.TLS, db uintptr, iIdx int32, ppValue uintptr) (r int32)
• func Xsqlite3_preupdate_old(tls *libc.TLS, db uintptr, iIdx int32, ppValue uintptr) (r int32)
• func Xsqlite3_profile(tls *libc.TLS, db uintptr, xProfile uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_progress_handler(tls *libc.TLS, db uintptr, nOps int32, xProgress uintptr, pArg uintptr)
• func Xsqlite3_randomness(tls *libc.TLS, N int32, pBuf uintptr)
• func Xsqlite3_realloc(tls *libc.TLS, pOld uintptr, n int32) (r uintptr)
• func Xsqlite3_realloc64(tls *libc.TLS, pOld uintptr, n Tsqlite3_uint64) (r uintptr)
• func Xsqlite3_release_memory(tls *libc.TLS, n int32) (r int32)
• func Xsqlite3_reset(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_reset_auto_extension(tls *libc.TLS)
• func Xsqlite3_result_blob(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)
• func Xsqlite3_result_blob64(tls *libc.TLS, pCtx uintptr, z uintptr, n Tsqlite3_uint64, xDel uintptr)
• func Xsqlite3_result_double(tls *libc.TLS, pCtx uintptr, rVal float64)
• func Xsqlite3_result_error(tls *libc.TLS, pCtx uintptr, z uintptr, n int32)
• func Xsqlite3_result_error16(tls *libc.TLS, pCtx uintptr, z uintptr, n int32)
• func Xsqlite3_result_error_code(tls *libc.TLS, pCtx uintptr, errCode int32)
• func Xsqlite3_result_error_nomem(tls *libc.TLS, pCtx uintptr)
• func Xsqlite3_result_error_toobig(tls *libc.TLS, pCtx uintptr)
• func Xsqlite3_result_int(tls *libc.TLS, pCtx uintptr, iVal int32)
• func Xsqlite3_result_int64(tls *libc.TLS, pCtx uintptr, iVal Ti64)
• func Xsqlite3_result_null(tls *libc.TLS, pCtx uintptr)
• func Xsqlite3_result_pointer(tls *libc.TLS, pCtx uintptr, pPtr uintptr, zPType uintptr, xDestructor uintptr)
• func Xsqlite3_result_subtype(tls *libc.TLS, pCtx uintptr, eSubtype uint32)
• func Xsqlite3_result_text(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)
• func Xsqlite3_result_text16(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)
• func Xsqlite3_result_text16be(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)
• func Xsqlite3_result_text16le(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)
• func Xsqlite3_result_text64(tls *libc.TLS, pCtx uintptr, z uintptr, n Tsqlite3_uint64, xDel uintptr, ...)
• func Xsqlite3_result_value(tls *libc.TLS, pCtx uintptr, pValue uintptr)
• func Xsqlite3_result_zeroblob(tls *libc.TLS, pCtx uintptr, n int32)
• func Xsqlite3_result_zeroblob64(tls *libc.TLS, pCtx uintptr, n Tu64) (r int32)
• func Xsqlite3_rollback_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_rtree_geometry_callback(tls *libc.TLS, db uintptr, zGeom uintptr, xGeom uintptr, pContext uintptr) (r int32)
• func Xsqlite3_rtree_query_callback(tls *libc.TLS, db uintptr, zQueryFunc uintptr, xQueryFunc uintptr, ...) (r int32)
• func Xsqlite3_serialize(tls *libc.TLS, db uintptr, zSchema uintptr, piSize uintptr, mFlags uint32) (r uintptr)
• func Xsqlite3_set_authorizer(tls *libc.TLS, db uintptr, xAuth uintptr, pArg uintptr) (r int32)
• func Xsqlite3_set_auxdata(tls *libc.TLS, pCtx uintptr, iArg int32, pAux uintptr, xDelete uintptr)
• func Xsqlite3_set_clientdata(tls *libc.TLS, db uintptr, zName uintptr, pData uintptr, xDestructor uintptr) (r int32)
• func Xsqlite3_set_last_insert_rowid(tls *libc.TLS, db uintptr, iRowid Tsqlite3_int64)
• func Xsqlite3_shutdown(tls *libc.TLS) (r int32)
• func Xsqlite3_sleep(tls *libc.TLS, ms int32) (r int32)
• func Xsqlite3_snapshot_cmp(tls *libc.TLS, p1 uintptr, p2 uintptr) (r int32)
• func Xsqlite3_snapshot_free(tls *libc.TLS, pSnapshot uintptr)
• func Xsqlite3_snapshot_get(tls *libc.TLS, db uintptr, zDb uintptr, ppSnapshot uintptr) (r int32)
• func Xsqlite3_snapshot_open(tls *libc.TLS, db uintptr, zDb uintptr, pSnapshot uintptr) (r int32)
• func Xsqlite3_snapshot_recover(tls *libc.TLS, db uintptr, zDb uintptr) (r int32)
• func Xsqlite3_snprintf(tls *libc.TLS, n int32, zBuf uintptr, zFormat uintptr, va uintptr) (r uintptr)
• func Xsqlite3_soft_heap_limit(tls *libc.TLS, n int32)
• func Xsqlite3_sourceid(tls *libc.TLS) (r uintptr)
• func Xsqlite3_sql(tls *libc.TLS, pStmt uintptr) (r uintptr)
• func Xsqlite3_status(tls *libc.TLS, op int32, pCurrent uintptr, pHighwater uintptr, resetFlag int32) (r int32)
• func Xsqlite3_status64(tls *libc.TLS, op int32, pCurrent uintptr, pHighwater uintptr, resetFlag int32) (r int32)
• func Xsqlite3_step(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_stmt_busy(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_stmt_explain(tls *libc.TLS, pStmt uintptr, eMode int32) (r int32)
• func Xsqlite3_stmt_isexplain(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_stmt_readonly(tls *libc.TLS, pStmt uintptr) (r int32)
• func Xsqlite3_stmt_status(tls *libc.TLS, pStmt uintptr, op int32, resetFlag int32) (r int32)
• func Xsqlite3_str_append(tls *libc.TLS, p uintptr, z uintptr, N int32)
• func Xsqlite3_str_appendall(tls *libc.TLS, p uintptr, z uintptr)
• func Xsqlite3_str_appendchar(tls *libc.TLS, p uintptr, N int32, c int8)
• func Xsqlite3_str_appendf(tls *libc.TLS, p uintptr, zFormat uintptr, va uintptr)
• func Xsqlite3_str_errcode(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_str_finish(tls *libc.TLS, p uintptr) (r uintptr)
• func Xsqlite3_str_length(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_str_new(tls *libc.TLS, db uintptr) (r uintptr)
• func Xsqlite3_str_reset(tls *libc.TLS, p uintptr)
• func Xsqlite3_str_value(tls *libc.TLS, p uintptr) (r uintptr)
• func Xsqlite3_str_vappendf(tls *libc.TLS, pAccum uintptr, fmt uintptr, ap Tva_list)
• func Xsqlite3_strglob(tls *libc.TLS, zGlobPattern uintptr, zString uintptr) (r int32)
• func Xsqlite3_stricmp(tls *libc.TLS, zLeft uintptr, zRight uintptr) (r int32)
• func Xsqlite3_strlike(tls *libc.TLS, zPattern uintptr, zStr uintptr, esc uint32) (r int32)
• func Xsqlite3_strnicmp(tls *libc.TLS, zLeft uintptr, zRight uintptr, N int32) (r int32)
• func Xsqlite3_system_errno(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_table_column_metadata(tls *libc.TLS, db uintptr, zDbName uintptr, zTableName uintptr, ...) (r int32)
• func Xsqlite3_test_control(tls *libc.TLS, op int32, va uintptr) (r int32)
• func Xsqlite3_thread_cleanup(tls *libc.TLS)
• func Xsqlite3_threadsafe(tls *libc.TLS) (r int32)
• func Xsqlite3_total_changes(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_trace(tls *libc.TLS, db uintptr, xTrace uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_trace_v2(tls *libc.TLS, db uintptr, mTrace uint32, xTrace uintptr, pArg uintptr) (r int32)
• func Xsqlite3_transfer_bindings(tls *libc.TLS, pFromStmt uintptr, pToStmt uintptr) (r int32)
• func Xsqlite3_txn_state(tls *libc.TLS, db uintptr, zSchema uintptr) (r int32)
• func Xsqlite3_unlock_notify(tls *libc.TLS, db uintptr, xNotify uintptr, _pArg uintptr) (r int32)
• func Xsqlite3_update_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3_uri_boolean(tls *libc.TLS, zFilename uintptr, zParam uintptr, bDflt int32) (r int32)
• func Xsqlite3_uri_key(tls *libc.TLS, zFilename uintptr, N int32) (r uintptr)
• func Xsqlite3_uri_parameter(tls *libc.TLS, zFilename uintptr, zParam uintptr) (r uintptr)
• func Xsqlite3_user_data(tls *libc.TLS, p uintptr) (r uintptr)
• func Xsqlite3_value_blob(tls *libc.TLS, pVal uintptr) (r uintptr)
• func Xsqlite3_value_bytes(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_bytes16(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_double(tls *libc.TLS, pVal uintptr) (r float64)
• func Xsqlite3_value_dup(tls *libc.TLS, pOrig uintptr) (r uintptr)
• func Xsqlite3_value_encoding(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_free(tls *libc.TLS, pOld uintptr)
• func Xsqlite3_value_frombind(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_int(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_nochange(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_numeric_type(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_value_pointer(tls *libc.TLS, pVal uintptr, zPType uintptr) (r uintptr)
• func Xsqlite3_value_subtype(tls *libc.TLS, pVal uintptr) (r uint32)
• func Xsqlite3_value_text(tls *libc.TLS, pVal uintptr) (r uintptr)
• func Xsqlite3_value_text16(tls *libc.TLS, pVal uintptr) (r uintptr)
• func Xsqlite3_value_text16be(tls *libc.TLS, pVal uintptr) (r uintptr)
• func Xsqlite3_value_text16le(tls *libc.TLS, pVal uintptr) (r uintptr)
• func Xsqlite3_value_type(tls *libc.TLS, pVal uintptr) (r int32)
• func Xsqlite3_vfs_find(tls *libc.TLS, zVfs uintptr) (r uintptr)
• func Xsqlite3_vfs_register(tls *libc.TLS, pVfs uintptr, makeDflt int32) (r int32)
• func Xsqlite3_vfs_unregister(tls *libc.TLS, pVfs uintptr) (r int32)
• func Xsqlite3_vmprintf(tls *libc.TLS, zFormat uintptr, ap Tva_list) (r uintptr)
• func Xsqlite3_vsnprintf(tls *libc.TLS, n int32, zBuf uintptr, zFormat uintptr, ap Tva_list) (r uintptr)
• func Xsqlite3_vtab_collation(tls *libc.TLS, pIdxInfo uintptr, iCons int32) (r uintptr)
• func Xsqlite3_vtab_config(tls *libc.TLS, db uintptr, op int32, va uintptr) (r int32)
• func Xsqlite3_vtab_distinct(tls *libc.TLS, pIdxInfo uintptr) (r int32)
• func Xsqlite3_vtab_in(tls *libc.TLS, pIdxInfo uintptr, iCons int32, bHandle int32) (r int32)
• func Xsqlite3_vtab_in_first(tls *libc.TLS, pVal uintptr, ppOut uintptr) (r int32)
• func Xsqlite3_vtab_in_next(tls *libc.TLS, pVal uintptr, ppOut uintptr) (r int32)
• func Xsqlite3_vtab_nochange(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3_vtab_on_conflict(tls *libc.TLS, db uintptr) (r int32)
• func Xsqlite3_vtab_rhs_value(tls *libc.TLS, pIdxInfo uintptr, iCons int32, ppVal uintptr) (r int32)
• func Xsqlite3_wal_autocheckpoint(tls *libc.TLS, db uintptr, nFrame int32) (r int32)
• func Xsqlite3_wal_checkpoint(tls *libc.TLS, db uintptr, zDb uintptr) (r int32)
• func Xsqlite3_wal_checkpoint_v2(tls *libc.TLS, db uintptr, zDb uintptr, eMode int32, pnLog uintptr, ...) (r int32)
• func Xsqlite3_wal_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)
• func Xsqlite3changegroup_add(tls *libc.TLS, pGrp uintptr, nData int32, pData uintptr) (r int32)
• func Xsqlite3changegroup_add_change(tls *libc.TLS, pGrp uintptr, pIter uintptr) (r int32)
• func Xsqlite3changegroup_add_strm(tls *libc.TLS, pGrp uintptr, xInput uintptr, pIn uintptr) (r int32)
• func Xsqlite3changegroup_delete(tls *libc.TLS, pGrp uintptr)
• func Xsqlite3changegroup_new(tls *libc.TLS, pp uintptr) (r int32)
• func Xsqlite3changegroup_output(tls *libc.TLS, pGrp uintptr, pnData uintptr, ppData uintptr) (r int32)
• func Xsqlite3changegroup_output_strm(tls *libc.TLS, pGrp uintptr, xOutput uintptr, pOut uintptr) (r int32)
• func Xsqlite3changegroup_schema(tls *libc.TLS, pGrp uintptr, db uintptr, zDb uintptr) (r int32)
• func Xsqlite3changeset_apply(tls *libc.TLS, db uintptr, nChangeset int32, pChangeset uintptr, ...) (r int32)
• func Xsqlite3changeset_apply_strm(tls *libc.TLS, db uintptr, xInput uintptr, pIn uintptr, xFilter uintptr, ...) (r int32)
• func Xsqlite3changeset_apply_v2(tls *libc.TLS, db uintptr, nChangeset int32, pChangeset uintptr, ...) (r int32)
• func Xsqlite3changeset_apply_v2_strm(tls *libc.TLS, db uintptr, xInput uintptr, pIn uintptr, xFilter uintptr, ...) (r int32)
• func Xsqlite3changeset_concat(tls *libc.TLS, nLeft int32, pLeft uintptr, nRight int32, pRight uintptr, ...) (r int32)
• func Xsqlite3changeset_concat_strm(tls *libc.TLS, xInputA uintptr, pInA uintptr, xInputB uintptr, pInB uintptr, ...) (r int32)
• func Xsqlite3changeset_conflict(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)
• func Xsqlite3changeset_finalize(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3changeset_fk_conflicts(tls *libc.TLS, pIter uintptr, pnOut uintptr) (r int32)
• func Xsqlite3changeset_invert(tls *libc.TLS, nChangeset int32, pChangeset uintptr, pnInverted uintptr, ...) (r int32)
• func Xsqlite3changeset_invert_strm(tls *libc.TLS, xInput uintptr, pIn uintptr, xOutput uintptr, pOut uintptr) (r int32)
• func Xsqlite3changeset_new(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)
• func Xsqlite3changeset_next(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3changeset_old(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)
• func Xsqlite3changeset_op(tls *libc.TLS, pIter uintptr, pzTab uintptr, pnCol uintptr, pOp uintptr, ...) (r int32)
• func Xsqlite3changeset_pk(tls *libc.TLS, pIter uintptr, pabPK uintptr, pnCol uintptr) (r int32)
• func Xsqlite3changeset_start(tls *libc.TLS, pp uintptr, nChangeset int32, pChangeset uintptr) (r int32)
• func Xsqlite3changeset_start_strm(tls *libc.TLS, pp uintptr, xInput uintptr, pIn uintptr) (r int32)
• func Xsqlite3changeset_start_v2(tls *libc.TLS, pp uintptr, nChangeset int32, pChangeset uintptr, flags int32) (r int32)
• func Xsqlite3changeset_start_v2_strm(tls *libc.TLS, pp uintptr, xInput uintptr, pIn uintptr, flags int32) (r int32)
• func Xsqlite3rbu_bp_progress(tls *libc.TLS, p uintptr, pnOne uintptr, pnTwo uintptr)
• func Xsqlite3rbu_close(tls *libc.TLS, p uintptr, pzErrmsg uintptr) (r int32)
• func Xsqlite3rbu_create_vfs(tls *libc.TLS, zName uintptr, zParent uintptr) (r int32)
• func Xsqlite3rbu_db(tls *libc.TLS, pRbu uintptr, bRbu int32) (r uintptr)
• func Xsqlite3rbu_destroy_vfs(tls *libc.TLS, zName uintptr)
• func Xsqlite3rbu_open(tls *libc.TLS, zTarget uintptr, zRbu uintptr, zState uintptr) (r uintptr)
• func Xsqlite3rbu_rename_handler(tls *libc.TLS, pRbu uintptr, pArg uintptr, xRename uintptr)
• func Xsqlite3rbu_savestate(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3rbu_state(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3rbu_step(tls *libc.TLS, p uintptr) (r int32)
• func Xsqlite3rbu_vacuum(tls *libc.TLS, zTarget uintptr, zState uintptr) (r uintptr)
• func Xsqlite3rebaser_configure(tls *libc.TLS, p uintptr, nRebase int32, pRebase uintptr) (r int32)
• func Xsqlite3rebaser_create(tls *libc.TLS, ppNew uintptr) (r int32)
• func Xsqlite3rebaser_delete(tls *libc.TLS, p uintptr)
• func Xsqlite3rebaser_rebase(tls *libc.TLS, p uintptr, nIn int32, pIn uintptr, pnOut uintptr, ppOut uintptr) (r int32)
• func Xsqlite3rebaser_rebase_strm(tls *libc.TLS, p uintptr, xInput uintptr, pIn uintptr, xOutput uintptr, ...) (r int32)
• func Xsqlite3session_attach(tls *libc.TLS, pSession uintptr, zName uintptr) (r int32)
• func Xsqlite3session_changeset(tls *libc.TLS, pSession uintptr, pnChangeset uintptr, ppChangeset uintptr) (r int32)
• func Xsqlite3session_changeset_strm(tls *libc.TLS, pSession uintptr, xOutput uintptr, pOut uintptr) (r int32)
• func Xsqlite3session_config(tls *libc.TLS, op int32, pArg uintptr) (r int32)
• func Xsqlite3session_create(tls *libc.TLS, db uintptr, zDb uintptr, ppSession uintptr) (r int32)
• func Xsqlite3session_delete(tls *libc.TLS, pSession uintptr)
• func Xsqlite3session_diff(tls *libc.TLS, pSession uintptr, zFrom uintptr, zTbl uintptr, pzErrMsg uintptr) (r int32)
• func Xsqlite3session_enable(tls *libc.TLS, pSession uintptr, bEnable int32) (r int32)
• func Xsqlite3session_indirect(tls *libc.TLS, pSession uintptr, bIndirect int32) (r int32)
• func Xsqlite3session_isempty(tls *libc.TLS, pSession uintptr) (r int32)
• func Xsqlite3session_object_config(tls *libc.TLS, pSession uintptr, op int32, pArg uintptr) (r int32)
• func Xsqlite3session_patchset(tls *libc.TLS, pSession uintptr, pnPatchset uintptr, ppPatchset uintptr) (r int32)
• func Xsqlite3session_patchset_strm(tls *libc.TLS, pSession uintptr, xOutput uintptr, pOut uintptr) (r int32)
• func Xsqlite3session_table_filter(tls *libc.TLS, pSession uintptr, xFilter uintptr, pCtx uintptr)
• type AggInfo
• type AggInfo1
• type AggInfo_col
• type AggInfo_func
• type AsciiTokenizer
• type AsciiTokenizer1
• type AuthContext
• type AuthContext1
• type AutoincInfo
• type AutoincInfo1
• type AuxData
• type AuxData1
• type BenignMallocHooks
• type BenignMallocHooks1
• type Bitmask
• type Bitvec
• type Bitvec1
• type Bool
• type BtCursor
• type BtCursor1
• type BtLock
• type BtLock1
• type BtShared
• type BtShared1
• type Btree
• type Btree1
• type BtreePayload
• type BtreePayload1
• type BusyHandler
• type BusyHandler1
• type CInstIter
• type CInstIter1
• type CallCount
• type CellArray
• type CellArray1
• type CellInfo
• type CellInfo1
• type CollSeq
• type CollSeq1
• type Column
• type Column1
• type CountCtx
• type CountCtx1
• type CoveringIndexCheck
• type CoveringIndexCheck1
• type Cte
• type Cte1
• type CteUse
• type CteUse1
• type DateTime
• type DateTime1
• type Db
• type Db1
• type DbClientData
• type DbClientData1
• type DbFixer
• type DbFixer1
• type DbPage
• type DbPath
• type DbPath1
• type DblquoteStr
• type DblquoteStr1
• type DistinctCtx
• type DistinctCtx1
• type Dl_info
• type EdupBuf
• type EdupBuf1
• type Expr
• type Expr1
• type ExprList
• type ExprList1
• type ExprList_item
• type FKey
• type FKey1
• type FileChunk
• type FileChunk1
• type FilePoint
• type FilePoint1
• type FpDecode
• type FpDecode1
• type FrameBound
• type Fts5Auxdata
• type Fts5Auxdata1
• type Fts5Auxiliary
• type Fts5Auxiliary1
• type Fts5Bm25Data
• type Fts5Bm25Data1
• type Fts5Buffer
• type Fts5Buffer1
• type Fts5CResult
• type Fts5CResult1
• type Fts5Colset
• type Fts5Colset1
• type Fts5Config
• type Fts5Config1
• type Fts5Cursor
• type Fts5Cursor1
• type Fts5Data
• type Fts5Data1
• type Fts5DlidxIter
• type Fts5DlidxIter1
• type Fts5DlidxLvl
• type Fts5DlidxLvl1
• type Fts5DlidxWriter
• type Fts5DlidxWriter1
• type Fts5DoclistIter
• type Fts5DoclistIter1
• type Fts5Enum
• type Fts5Enum1
• type Fts5Expr
• type Fts5Expr1
• type Fts5ExprCtx
• type Fts5ExprCtx1
• type Fts5ExprNearset
• type Fts5ExprNearset1
• type Fts5ExprNode
• type Fts5ExprNode1
• type Fts5ExprPhrase
• type Fts5ExprPhrase1
• type Fts5ExprTerm
• type Fts5ExprTerm1
• type Fts5ExtensionApi
• type Fts5ExtensionApi1
• type Fts5FlushCtx
• type Fts5FlushCtx1
• type Fts5FullTable
• type Fts5FullTable1
• type Fts5Global
• type Fts5Global1
• type Fts5Hash
• type Fts5Hash1
• type Fts5HashEntry
• type Fts5HashEntry1
• type Fts5Index
• type Fts5Index1
• type Fts5IndexIter
• type Fts5IndexIter1
• type Fts5InsertCtx
• type Fts5InsertCtx1
• type Fts5IntegrityCtx
• type Fts5IntegrityCtx1
• type Fts5Iter
• type Fts5Iter1
• type Fts5LookaheadReader
• type Fts5LookaheadReader1
• type Fts5MatchPhrase
• type Fts5NearTrimmer
• type Fts5NearTrimmer1
• type Fts5PageWriter
• type Fts5PageWriter1
• type Fts5Parse
• type Fts5Parse1
• type Fts5PhraseIter
• type Fts5PhraseIter1
• type Fts5PoslistPopulator
• type Fts5PoslistPopulator1
• type Fts5PoslistReader
• type Fts5PoslistReader1
• type Fts5PoslistWriter
• type Fts5PoslistWriter1
• type Fts5SFinder
• type Fts5SFinder1
• type Fts5SegIter
• type Fts5SegIter1
• type Fts5SegWriter
• type Fts5SegWriter1
• type Fts5Sorter
• type Fts5Sorter1
• type Fts5Storage
• type Fts5Storage1
• type Fts5Structure
• type Fts5Structure1
• type Fts5StructureLevel
• type Fts5StructureLevel1
• type Fts5StructureSegment
• type Fts5StructureSegment1
• type Fts5Table
• type Fts5Table1
• type Fts5Termset
• type Fts5Termset1
• type Fts5TermsetEntry
• type Fts5TermsetEntry1
• type Fts5Token
• type Fts5Token1
• type Fts5TokenDataIter
• type Fts5TokenDataIter1
• type Fts5TokenDataMap
• type Fts5TokenDataMap1
• type Fts5TokenizerModule
• type Fts5TokenizerModule1
• type Fts5TombstoneArray
• type Fts5TombstoneArray1
• type Fts5TransactionState
• type Fts5VocabCursor
• type Fts5VocabCursor1
• type Fts5VocabTable
• type Fts5VocabTable1
• type FuncDef
• type FuncDef1
• type FuncDefHash
• type FuncDefHash1
• type FuncDestructor
• type FuncDestructor1
• type GeoBBox
• type GeoBBox1
• type GeoCoord
• type GeoEvent
• type GeoEvent1
• type GeoOverlap
• type GeoOverlap1
• type GeoParse
• type GeoParse1
• type GeoPoly
• type GeoPoly1
• type GeoSegment
• type GeoSegment1
• type GroupConcatCtx
• type Hash
• type Hash1
• type HashElem
• type HashElem1
• type HiddenIndexInfo
• type HiddenIndexInfo1
• type HighlightContext
• type HighlightContext1
• type IdList
• type IdList1
• type IdList_item
• type IdxCover
• type InLoop
• type IncrMerger
• type IncrMerger1
• type Incrblob
• type Incrblob1
• type Index
• type Index1
• type IndexIterator
• type IndexIterator1
• type IndexListTerm
• type IndexListTerm1
• type IndexSample
• type IndexSample1
• type IndexedExpr
• type IndexedExpr1
• type InitData
• type IntegrityCk
• type IntegrityCk1
• type JsonCache
• type JsonCache1
• type JsonEachConnection
• type JsonEachConnection1
• type JsonEachCursor
• type JsonEachCursor1
• type JsonParent
• type JsonParent1
• type JsonParse
• type JsonParse1
• type JsonPretty
• type JsonPretty1
• type JsonString
• type JsonString1
• type KeyInfo
• type KeyInfo1
• type LastValueCtx
• type LogEst
• type Lookaside
• type Lookaside1
• type LookasideSlot
• type LookasideSlot1
• type Mem
• type Mem0Global
• type MemFS
• type MemFile
• type MemFile1
• type MemJournal
• type MemJournal1
• type MemPage
• type MemPage1
• type MemStore
• type MemStore1
• type MemValue
• type MemVfs
• type MergeEngine
• type MergeEngine1
• type Module
• type Module1
• type NameContext
• type NameContext1
• type NanInfName
• type NthValueCtx
• type NtileCtx
• type OnOrUsing
• type OnOrUsing1
• type Op
• type PCache
• type PCache1
• type PCache11
• type PCache2
• type PCacheGlobal
• type PGroup
• type PGroup1
• type Pager
• type Pager1
• type PagerSavepoint
• type PagerSavepoint1
• type Parse
• type Parse1
• type ParseCleanup
• type ParseCleanup1
• type PgFreeslot
• type PgFreeslot1
• type PgHdr
• type PgHdr1
• type PgHdr11
• type PgHdr2
• type Pgno
• type PmaReader
• type PmaReader1
• type PmaWriter
• type PmaWriter1
• type PorterContext
• type PorterContext1
• type PorterRule
• type PorterRule1
• type PorterTokenizer
• type PorterTokenizer1
• type PoslistCallbackCtx
• type PoslistCallbackCtx1
• type PoslistOffsetsCtx
• type PoslistOffsetsCtx1
• type PragmaName
• type PragmaVtab
• type PragmaVtab1
• type PragmaVtabCursor
• type PragmaVtabCursor1
• type PreUpdate
• type PreUpdate1
• type PrefixMerger
• type PrefixMerger1
• type PrintfArguments
• type PrintfArguments1
• type RCStr
• type RCStr1
• type RbuFrame
• type RbuFrame1
• type RbuObjIter
• type RbuObjIter1
• type RbuSpan
• type RbuSpan1
• type RbuState
• type RbuState1
• type RbuUpdateStmt
• type RbuUpdateStmt1
• type RecordCompare
• type RefSrcList
• type RenameCtx
• type RenameCtx1
• type RenameToken
• type RenameToken1
• type Returning
• type Returning1
• type ReusableSpace
• type RowLoadInfo
• type RowLoadInfo1
• type RowSet
• type RowSet1
• type RowSetChunk
• type RowSetEntry
• type Rtree
• type Rtree1
• type RtreeCell
• type RtreeCell1
• type RtreeCheck
• type RtreeCheck1
• type RtreeConstraint
• type RtreeConstraint1
• type RtreeCoord
• type RtreeCoord1
• type RtreeCursor
• type RtreeCursor1
• type RtreeDValue
• type RtreeGeomCallback
• type RtreeGeomCallback1
• type RtreeMatchArg
• type RtreeMatchArg1
• type RtreeNode
• type RtreeNode1
• type RtreeSearchPoint
• type RtreeSearchPoint1
• type RtreeValue
• type SQLiteThread
• type SQLiteThread1
• type Savepoint
• type Savepoint1
• type ScanStatus
• type ScanStatus1
• type Schema
• type Schema1
• type Select
• type Select1
• type SelectDest
• type SelectDest1
• type SessionApplyCtx
• type SessionApplyCtx1
• type SessionBuffer
• type SessionBuffer1
• type SessionChange
• type SessionChange1
• type SessionDiffCtx
• type SessionDiffCtx1
• type SessionHook
• type SessionHook1
• type SessionInput
• type SessionInput1
• type SessionStat1Ctx
• type SessionStat1Ctx1
• type SessionTable
• type SessionTable1
• type SessionUpdate
• type SessionUpdate1
• type SortCtx
• type SortCtx1
• type SortSubtask
• type SortSubtask1
• type SorterCompare
• type SorterFile
• type SorterFile1
• type SorterList
• type SorterList1
• type SorterRecord
• type SorterRecord1
• type Sqlite3Config
• type Sqlite3_index_constraint
• type Sqlite3_index_constraint_usage
• type Sqlite3_index_info
• type Sqlite3_index_orderby
• type Sqlite3_int64
• type Sqlite3_module
• type Sqlite3_mutex_methods
• type Sqlite3_value
• type Sqlite3_vtab
• type Sqlite3_vtab_cursor
• type SrcItem
• type SrcItem1
• type SrcList
• type SrcList1
• type StatAccum
• type StatAccum1
• type StatCell
• type StatCell1
• type StatCursor
• type StatCursor1
• type StatPage
• type StatPage1
• type StatSample
• type StatSample1
• type StatTable
• type StatTable1
• type StrAccum
• type SubProgram
• type SubProgram1
• type SubstContext
• type SumCtx
• type SumCtx1
• type TAggInfo
• type TAggInfo1
• type TAggInfo_col
• type TAggInfo_func
• type TAsciiTokenizer
• type TAsciiTokenizer1
• type TAuthContext
• type TAuthContext1
• type TAutoincInfo
• type TAutoincInfo1
• type TAuxData
• type TAuxData1
• type TBenignMallocHooks
• type TBenignMallocHooks1
• type TBitmask
• type TBitvec
• type TBitvec1
• type TBool
• type TBtCursor
• type TBtCursor1
• type TBtLock
• type TBtLock1
• type TBtShared
• type TBtShared1
• type TBtree
• type TBtree1
• type TBtreePayload
• type TBtreePayload1
• type TBusyHandler
• type TBusyHandler1
• type TCInstIter
• type TCInstIter1
• type TCallCount
• type TCellArray
• type TCellArray1
• type TCellInfo
• type TCellInfo1
• type TCollSeq
• type TCollSeq1
• type TColumn
• type TColumn1
• type TCountCtx
• type TCountCtx1
• type TCoveringIndexCheck
• type TCoveringIndexCheck1
• type TCte
• type TCte1
• type TCteUse
• type TCteUse1
• type TDateTime
• type TDateTime1
• type TDb
• type TDb1
• type TDbClientData
• type TDbClientData1
• type TDbFixer
• type TDbFixer1
• type TDbPage
• type TDbPath
• type TDbPath1
• type TDblquoteStr
• type TDblquoteStr1
• type TDistinctCtx
• type TDistinctCtx1
• type TDl_info
• type TEdupBuf
• type TEdupBuf1
• type TExpr
• type TExpr1
• type TExprList
• type TExprList1
• type TExprList_item
• type TFKey
• type TFKey1
• type TFileChunk
• type TFileChunk1
• type TFilePoint
• type TFilePoint1
• type TFpDecode
• type TFpDecode1
• type TFrameBound
• type TFts5Auxdata
• type TFts5Auxdata1
• type TFts5Auxiliary
• type TFts5Auxiliary1
• type TFts5Bm25Data
• type TFts5Bm25Data1
• type TFts5Buffer
• type TFts5Buffer1
• type TFts5CResult
• type TFts5CResult1
• type TFts5Colset
• type TFts5Colset1
• type TFts5Config
• type TFts5Config1
• type TFts5Cursor
• type TFts5Cursor1
• type TFts5Data
• type TFts5Data1
• type TFts5DlidxIter
• type TFts5DlidxIter1
• type TFts5DlidxLvl
• type TFts5DlidxLvl1
• type TFts5DlidxWriter
• type TFts5DlidxWriter1
• type TFts5DoclistIter
• type TFts5DoclistIter1
• type TFts5Enum
• type TFts5Enum1
• type TFts5Expr
• type TFts5Expr1
• type TFts5ExprCtx
• type TFts5ExprCtx1
• type TFts5ExprNearset
• type TFts5ExprNearset1
• type TFts5ExprNode
• type TFts5ExprNode1
• type TFts5ExprPhrase
• type TFts5ExprPhrase1
• type TFts5ExprTerm
• type TFts5ExprTerm1
• type TFts5ExtensionApi
• type TFts5ExtensionApi1
• type TFts5FlushCtx
• type TFts5FlushCtx1
• type TFts5FullTable
• type TFts5FullTable1
• type TFts5Global
• type TFts5Global1
• type TFts5Hash
• type TFts5Hash1
• type TFts5HashEntry
• type TFts5HashEntry1
• type TFts5Index
• type TFts5Index1
• type TFts5IndexIter
• type TFts5IndexIter1
• type TFts5InsertCtx
• type TFts5InsertCtx1
• type TFts5IntegrityCtx
• type TFts5IntegrityCtx1
• type TFts5Iter
• type TFts5Iter1
• type TFts5LookaheadReader
• type TFts5LookaheadReader1
• type TFts5MatchPhrase
• type TFts5NearTrimmer
• type TFts5NearTrimmer1
• type TFts5PageWriter
• type TFts5PageWriter1
• type TFts5Parse
• type TFts5Parse1
• type TFts5PhraseIter
• type TFts5PhraseIter1
• type TFts5PoslistPopulator
• type TFts5PoslistPopulator1
• type TFts5PoslistReader
• type TFts5PoslistReader1
• type TFts5PoslistWriter
• type TFts5PoslistWriter1
• type TFts5SFinder
• type TFts5SFinder1
• type TFts5SegIter
• type TFts5SegIter1
• type TFts5SegWriter
• type TFts5SegWriter1
• type TFts5Sorter
• type TFts5Sorter1
• type TFts5Storage
• type TFts5Storage1
• type TFts5Structure
• type TFts5Structure1
• type TFts5StructureLevel
• type TFts5StructureLevel1
• type TFts5StructureSegment
• type TFts5StructureSegment1
• type TFts5Table
• type TFts5Table1
• type TFts5Termset
• type TFts5Termset1
• type TFts5TermsetEntry
• type TFts5TermsetEntry1
• type TFts5Token
• type TFts5Token1
• type TFts5TokenDataIter
• type TFts5TokenDataIter1
• type TFts5TokenDataMap
• type TFts5TokenDataMap1
• type TFts5TokenizerModule
• type TFts5TokenizerModule1
• type TFts5TombstoneArray
• type TFts5TombstoneArray1
• type TFts5TransactionState
• type TFts5VocabCursor
• type TFts5VocabCursor1
• type TFts5VocabTable
• type TFts5VocabTable1
• type TFuncDef
• type TFuncDef1
• type TFuncDefHash
• type TFuncDefHash1
• type TFuncDestructor
• type TFuncDestructor1
• type TGeoBBox
• type TGeoBBox1
• type TGeoCoord
• type TGeoEvent
• type TGeoEvent1
• type TGeoOverlap
• type TGeoOverlap1
• type TGeoParse
• type TGeoParse1
• type TGeoPoly
• type TGeoPoly1
• type TGeoSegment
• type TGeoSegment1
• type TGroupConcatCtx
• type THash
• type THash1
• type THashElem
• type THashElem1
• type THiddenIndexInfo
• type THiddenIndexInfo1
• type THighlightContext
• type THighlightContext1
• type TIdList
• type TIdList1
• type TIdList_item
• type TIdxCover
• type TInLoop
• type TIncrMerger
• type TIncrMerger1
• type TIncrblob
• type TIncrblob1
• type TIndex
• type TIndex1
• type TIndexIterator
• type TIndexIterator1
• type TIndexListTerm
• type TIndexListTerm1
• type TIndexSample
• type TIndexSample1
• type TIndexedExpr
• type TIndexedExpr1
• type TInitData
• type TIntegrityCk
• type TIntegrityCk1
• type TJsonCache
• type TJsonCache1
• type TJsonEachConnection
• type TJsonEachConnection1
• type TJsonEachCursor
• type TJsonEachCursor1
• type TJsonParent
• type TJsonParent1
• type TJsonParse
• type TJsonParse1
• type TJsonPretty
• type TJsonPretty1
• type TJsonString
• type TJsonString1
• type TKeyInfo
• type TKeyInfo1
• type TLastValueCtx
• type TLogEst
• type TLookaside
• type TLookaside1
• type TLookasideSlot
• type TLookasideSlot1
• type TMem
• type TMem0Global
• type TMemFS
• type TMemFile
• type TMemFile1
• type TMemJournal
• type TMemJournal1
• type TMemPage
• type TMemPage1
• type TMemStore
• type TMemStore1
• type TMemValue
• type TMemVfs
• type TMergeEngine
• type TMergeEngine1
• type TModule
• type TModule1
• type TNameContext
• type TNameContext1
• type TNanInfName
• type TNthValueCtx
• type TNtileCtx
• type TOnOrUsing
• type TOnOrUsing1
• type TOp
• type TPCache
• type TPCache1
• type TPCache11
• type TPCache2
• type TPCacheGlobal
• type TPGroup
• type TPGroup1
• type TPager
• type TPager1
• type TPagerSavepoint
• type TPagerSavepoint1
• type TParse
• type TParse1
• type TParseCleanup
• type TParseCleanup1
• type TPgFreeslot
• type TPgFreeslot1
• type TPgHdr
• type TPgHdr1
• type TPgHdr11
• type TPgHdr2
• type TPgno
• type TPmaReader
• type TPmaReader1
• type TPmaWriter
• type TPmaWriter1
• type TPorterContext
• type TPorterContext1
• type TPorterRule
• type TPorterRule1
• type TPorterTokenizer
• type TPorterTokenizer1
• type TPoslistCallbackCtx
• type TPoslistCallbackCtx1
• type TPoslistOffsetsCtx
• type TPoslistOffsetsCtx1
• type TPragmaName
• type TPragmaVtab
• type TPragmaVtab1
• type TPragmaVtabCursor
• type TPragmaVtabCursor1
• type TPreUpdate
• type TPreUpdate1
• type TPrefixMerger
• type TPrefixMerger1
• type TPrintfArguments
• type TPrintfArguments1
• type TRCStr
• type TRCStr1
• type TRbuFrame
• type TRbuFrame1
• type TRbuObjIter
• type TRbuObjIter1
• type TRbuSpan
• type TRbuSpan1
• type TRbuState
• type TRbuState1
• type TRbuUpdateStmt
• type TRbuUpdateStmt1
• type TRecordCompare
• type TRefSrcList
• type TRenameCtx
• type TRenameCtx1
• type TRenameToken
• type TRenameToken1
• type TReturning
• type TReturning1
• type TReusableSpace
• type TRowLoadInfo
• type TRowLoadInfo1
• type TRowSet
• type TRowSet1
• type TRowSetChunk
• type TRowSetEntry
• type TRtree
• type TRtree1
• type TRtreeCell
• type TRtreeCell1
• type TRtreeCheck
• type TRtreeCheck1
• type TRtreeConstraint
• type TRtreeConstraint1
• type TRtreeCoord
• type TRtreeCoord1
• type TRtreeCursor
• type TRtreeCursor1
• type TRtreeDValue
• type TRtreeGeomCallback
• type TRtreeGeomCallback1
• type TRtreeMatchArg
• type TRtreeMatchArg1
• type TRtreeNode
• type TRtreeNode1
• type TRtreeSearchPoint
• type TRtreeSearchPoint1
• type TRtreeValue
• type TSQLiteThread
• type TSQLiteThread1
• type TSavepoint
• type TSavepoint1
• type TScanStatus
• type TScanStatus1
• type TSchema
• type TSchema1
• type TSelect
• type TSelect1
• type TSelectDest
• type TSelectDest1
• type TSessionApplyCtx
• type TSessionApplyCtx1
• type TSessionBuffer
• type TSessionBuffer1
• type TSessionChange
• type TSessionChange1
• type TSessionDiffCtx
• type TSessionDiffCtx1
• type TSessionHook
• type TSessionHook1
• type TSessionInput
• type TSessionInput1
• type TSessionStat1Ctx
• type TSessionStat1Ctx1
• type TSessionTable
• type TSessionTable1
• type TSessionUpdate
• type TSessionUpdate1
• type TSortCtx
• type TSortCtx1
• type TSortSubtask
• type TSortSubtask1
• type TSorterCompare
• type TSorterFile
• type TSorterFile1
• type TSorterList
• type TSorterList1
• type TSorterRecord
• type TSorterRecord1
• type TSqlite3Config
• type TSrcItem
• type TSrcItem1
• type TSrcList
• type TSrcList1
• type TStatAccum
• type TStatAccum1
• type TStatCell
• type TStatCell1
• type TStatCursor
• type TStatCursor1
• type TStatPage
• type TStatPage1
• type TStatSample
• type TStatSample1
• type TStatTable
• type TStatTable1
• type TStrAccum
• type TSubProgram
• type TSubProgram1
• type TSubstContext
• type TSumCtx
• type TSumCtx1
• type TTabResult
• type TTable
• type TTable1
• type TTableLock
• type TTableLock1
• type TToken
• type TToken1
• type TTokenCtx
• type TTokenCtx1
• type TTrigEvent
• type TTrigger
• type TTrigger1
• type TTriggerPrg
• type TTriggerPrg1
• type TTriggerStep
• type TTriggerStep1
• type TTrigramTokenizer
• type TTrigramTokenizer1
• type TUnicode61Tokenizer
• type TUnicode61Tokenizer1
• type TUnixUnusedFd
• type TUnixUnusedFd1
• type TUnpackedRecord
• type TUnpackedRecord1
• type TUpsert
• type TUpsert1
• type TVList
• type TVTable
• type TVTable1
• type TValueList
• type TValueList1
• type TValueNewStat4Ctx
• type TVdbe
• type TVdbe1
• type TVdbeCursor
• type TVdbeCursor1
• type TVdbeFrame
• type TVdbeFrame1
• type TVdbeOp
• type TVdbeOp1
• type TVdbeOpList
• type TVdbeOpList1
• type TVdbeSorter
• type TVdbeSorter1
• type TVdbeTxtBlbCache
• type TVdbeTxtBlbCache1
• type TVtabCtx
• type TVtabCtx1
• type TWal
• type TWal1
• type TWalCkptInfo
• type TWalCkptInfo1
• type TWalHashLoc
• type TWalHashLoc1
• type TWalIndexHdr
• type TWalIndexHdr1
• type TWalIterator
• type TWalIterator1
• type TWalSegment
• type TWalWriter
• type TWalker
• type TWalker1
• type TWhereAndInfo
• type TWhereAndInfo1
• type TWhereClause
• type TWhereClause1
• type TWhereConst
• type TWhereConst1
• type TWhereInfo
• type TWhereInfo1
• type TWhereLevel
• type TWhereLevel1
• type TWhereLoop
• type TWhereLoop1
• type TWhereLoopBuilder
• type TWhereLoopBuilder1
• type TWhereMaskSet
• type TWhereMaskSet1
• type TWhereMemBlock
• type TWhereMemBlock1
• type TWhereOrCost
• type TWhereOrCost1
• type TWhereOrInfo
• type TWhereOrInfo1
• type TWhereOrSet
• type TWhereOrSet1
• type TWherePath
• type TWherePath1
• type TWhereRightJoin
• type TWhereRightJoin1
• type TWhereScan
• type TWhereScan1
• type TWhereTerm
• type TWhereTerm1
• type TWindow
• type TWindow1
• type TWindowCodeArg
• type TWindowCodeArg1
• type TWindowCsrAndReg
• type TWindowCsrAndReg1
• type TWindowRewrite
• type TWindowRewrite1
• type TWith
• type TWith1
• type TYYMINORTYPE
• type T_G_fpos64_t
• type T_IO_cookie_io_functions_t
• type T_ht
• type TabResult
• type Table
• type Table1
• type TableLock
• type TableLock1
• type TanalysisInfo
• type TanalysisInfo1
• type Tbft
• type Tblkcnt_t
• type Tblksize_t
• type Tcaddr_t
• type Tclock_t
• type Tclockid_t
• type TcompareInfo
• type Tcookie_io_functions_t
• type Tcpu_set_t
• type Tcpu_set_t1
• type Tdev_t
• type Tdiv_t
• type Tdouble_t
• type TetByte
• type Tet_info
• type Tf_owner_ex
• type Tfd_mask
• type Tfd_set
• type Tfile_handle
• type Tfinder_type
• type Tfloat_t
• type Tflock
• type Tfpos_t
• type Tfsblkcnt_t
• type Tfsfilcnt_t
• type Tfts5YYMINORTYPE
• type Tfts5_api
• type Tfts5_api1
• type Tfts5_extension_function
• type Tfts5_tokenizer
• type Tfts5_tokenizer1
• type Tfts5yyParser
• type Tfts5yyParser1
• type Tfts5yyStackEntry
• type Tfts5yyStackEntry1
• type Tgid_t
• type Tht_slot
• type Ti16
• type Ti64
• type Ti8
• type Tid_t
• type Tino_t
• type Tint16_t
• type Tint32_t
• type Tint64_t
• type Tint8_t
• type Tintptr_t
• type Tiovec
• type Titimerspec
• type Titimerval
• type Tkey_t
• type Tldiv_t
• type Tlldiv_t
• type Tlocale_t
• type Tmax_align_t
• type Tmode_t
• type Tnlink_t
• type Toff_t
• type Token
• type Token1
• type TokenCtx
• type TokenCtx1
• type Tp4union
• type Tpid_t
• type Tpthread_attr_t
• type Tpthread_barrier_t
• type Tpthread_barrierattr_t
• type Tpthread_cond_t
• type Tpthread_condattr_t
• type Tpthread_key_t
• type Tpthread_mutex_t
• type Tpthread_mutexattr_t
• type Tpthread_once_t
• type Tpthread_rwlock_t
• type Tpthread_rwlockattr_t
• type Tpthread_spinlock_t
• type Tpthread_t
• type Tptrdiff_t
• type Tquad_t
• type Trbu_file
• type Trbu_file1
• type Trbu_vfs
• type Trbu_vfs1
• type Tregister_t
• type TrigEvent
• type Trigger
• type Trigger1
• type TriggerPrg
• type TriggerPrg1
• type TriggerStep
• type TriggerStep1
• type TrigramTokenizer
• type TrigramTokenizer1
• type TsColMap
• type Tsched_param
• type Tsigset_t
• type Tsize_t
• type Tsqlite3
• type Tsqlite31
• type Tsqlite3AutoExtList
• type Tsqlite3AutoExtList1
• type Tsqlite3InitInfo
• type Tsqlite3PrngType
• type Tsqlite3StatType
• type Tsqlite3StatType1
• type Tsqlite3StatValueType
• type Tsqlite3_api_routines
• type Tsqlite3_api_routines1
• type Tsqlite3_backup
• type Tsqlite3_backup1
• type Tsqlite3_callback
• type Tsqlite3_changegroup
• type Tsqlite3_changegroup1
• type Tsqlite3_changeset_iter
• type Tsqlite3_changeset_iter1
• type Tsqlite3_context
• type Tsqlite3_context1
• type Tsqlite3_destructor_type
• type Tsqlite3_file
• type Tsqlite3_file1
• type Tsqlite3_filename
• type Tsqlite3_index_constraint
• type Tsqlite3_index_constraint_usage
• type Tsqlite3_index_info
• type Tsqlite3_index_info1
• type Tsqlite3_index_orderby
• type Tsqlite3_int64
  • func Xsqlite3_changes64(tls *libc.TLS, db uintptr) (r Tsqlite3_int64)
  • func Xsqlite3_hard_heap_limit64(tls *libc.TLS, n Tsqlite3_int64) (r Tsqlite3_int64)
  • func Xsqlite3_memory_highwater(tls *libc.TLS, resetFlag int32) (r Tsqlite3_int64)
  • func Xsqlite3_memory_used(tls *libc.TLS) (r Tsqlite3_int64)
  • func Xsqlite3_soft_heap_limit64(tls *libc.TLS, n Tsqlite3_int64) (r Tsqlite3_int64)
  • func Xsqlite3_total_changes64(tls *libc.TLS, db uintptr) (r Tsqlite3_int64)
  • func Xsqlite3_uri_int64(tls *libc.TLS, zFilename uintptr, zParam uintptr, bDflt Tsqlite3_int64) (r Tsqlite3_int64)
  • func Xsqlite3rbu_progress(tls *libc.TLS, pRbu uintptr) (r Tsqlite3_int64)
  • func Xsqlite3rbu_temp_size(tls *libc.TLS, pRbu uintptr) (r Tsqlite3_int64)
  • func Xsqlite3rbu_temp_size_limit(tls *libc.TLS, pRbu uintptr, n Tsqlite3_int64) (r Tsqlite3_int64)
  • func Xsqlite3session_changeset_size(tls *libc.TLS, pSession uintptr) (r Tsqlite3_int64)
  • func Xsqlite3session_memory_used(tls *libc.TLS, pSession uintptr) (r Tsqlite3_int64)
• type Tsqlite3_io_methods
• type Tsqlite3_io_methods1
• type Tsqlite3_loadext_entry
• type Tsqlite3_mem_methods
• type Tsqlite3_mem_methods1
• type Tsqlite3_module
• type Tsqlite3_module1
• type Tsqlite3_mutex
• type Tsqlite3_mutex1
• type Tsqlite3_mutex_methods
• type Tsqlite3_mutex_methods1
• type Tsqlite3_pcache_methods
• type Tsqlite3_pcache_methods1
• type Tsqlite3_pcache_methods2
• type Tsqlite3_pcache_methods21
• type Tsqlite3_pcache_page
• type Tsqlite3_pcache_page1
• type Tsqlite3_rebaser
• type Tsqlite3_rebaser1
• type Tsqlite3_rtree_dbl
• type Tsqlite3_rtree_geometry
• type Tsqlite3_rtree_geometry1
• type Tsqlite3_rtree_query_info
• type Tsqlite3_rtree_query_info1
• type Tsqlite3_session
• type Tsqlite3_session1
• type Tsqlite3_snapshot
• type Tsqlite3_str
• type Tsqlite3_str1
• type Tsqlite3_syscall_ptr
• type Tsqlite3_uint64
  • func Xsqlite3_msize(tls *libc.TLS, p uintptr) (r Tsqlite3_uint64)
• type Tsqlite3_value
• type Tsqlite3_value1
• type Tsqlite3_vfs
• type Tsqlite3_vfs1
• type Tsqlite3_vtab
• type Tsqlite3_vtab1
• type Tsqlite3_vtab_cursor
• type Tsqlite3_vtab_cursor1
• type Tsqlite3_xauth
• type Tsqlite3rbu
• type Tsqlite3rbu1
• type Tsqlite_int64
  • func Xsqlite3_column_int64(tls *libc.TLS, pStmt uintptr, i int32) (r Tsqlite_int64)
  • func Xsqlite3_last_insert_rowid(tls *libc.TLS, db uintptr) (r Tsqlite_int64)
  • func Xsqlite3_value_int64(tls *libc.TLS, pVal uintptr) (r Tsqlite_int64)
• type Tsqlite_uint64
• type Tssize_t
• type Tstat
• type Tstatx
• type Tstatx_timestamp
• type Tsuseconds_t
• type TtRowcnt
• type Ttime_t
• type Ttimer_t
• type Ttimespec
• type Ttimeval
• type Ttimezone
• type Ttm
• type Tu16
• type Tu32
• type Tu64
• type Tu8
• type Tu_char
• type Tu_int
• type Tu_int16_t
• type Tu_int32_t
• type Tu_int64_t
• type Tu_int8_t
• type Tu_long
• type Tu_quad_t
• type Tu_short
• type Tuid_t
• type Tuint
• type Tuint16_t
• type Tuint32_t
• type Tuint64_t
• type Tulong
• type TunixFile
• type TunixFile1
• type TunixFileId
• type TunixInodeInfo
• type TunixInodeInfo1
• type TunixShm
• type TunixShm1
• type TunixShmNode
• type TunixShmNode1
• type Tunix_syscall
• type Tuptr
• type Tuseconds_t
• type Tushort
• type Tva_list
• type TvxworksFileId
• type Twchar_t
• type Twinsize
• type TyDbMask
• type TynVar
• type TyyParser
• type TyyParser1
• type TyyStackEntry
• type TyyStackEntry1
• type Unicode61Tokenizer
• type Unicode61Tokenizer1
• type UnixUnusedFd
• type UnixUnusedFd1
• type UnpackedRecord
• type UnpackedRecord1
• type Upsert
• type Upsert1
• type VList
• type VTable
• type VTable1
• type ValueList
• type ValueList1
• type ValueNewStat4Ctx
• type Vdbe
• type Vdbe1
• type VdbeCursor
• type VdbeCursor1
• type VdbeFrame
• type VdbeFrame1
• type VdbeOp
• type VdbeOp1
• type VdbeOpList
• type VdbeOpList1
• type VdbeSorter
• type VdbeSorter1
• type VdbeTxtBlbCache
• type VdbeTxtBlbCache1
• type VtabCtx
• type VtabCtx1
• type Wal
• type Wal1
• type WalCkptInfo
• type WalCkptInfo1
• type WalHashLoc
• type WalHashLoc1
• type WalIndexHdr
• type WalIndexHdr1
• type WalIterator
• type WalIterator1
• type WalSegment
• type WalWriter
• type Walker
• type Walker1
• type WhereAndInfo
• type WhereAndInfo1
• type WhereClause
• type WhereClause1
• type WhereConst
• type WhereConst1
• type WhereInfo
• type WhereInfo1
• type WhereLevel
• type WhereLevel1
• type WhereLoop
• type WhereLoop1
• type WhereLoopBuilder
• type WhereLoopBuilder1
• type WhereMaskSet
• type WhereMaskSet1
• type WhereMemBlock
• type WhereMemBlock1
• type WhereOrCost
• type WhereOrCost1
• type WhereOrInfo
• type WhereOrInfo1
• type WhereOrSet
• type WhereOrSet1
• type WherePath
• type WherePath1
• type WhereRightJoin
• type WhereRightJoin1
• type WhereScan
• type WhereScan1
• type WhereTerm
• type WhereTerm1
• type Window
• type Window1
• type WindowCodeArg
• type WindowCodeArg1
• type WindowCsrAndReg
• type WindowCsrAndReg1
• type WindowRewrite
• type WindowRewrite1
• type With
• type With1
• type YYMINORTYPE

Constants

const (
	SQLITE_STATIC    = uintptr(0)  // ((sqlite3_destructor_type)0)
	SQLITE_TRANSIENT = ^uintptr(0) // ((sqlite3_destructor_type)-1)
)

const ALLBITS = -1

const AT_EACCESS = 512

const AT_EMPTY_PATH = 4096

const AT_FDCWD = -100

const AT_NO_AUTOMOUNT = 2048

const AT_RECURSIVE = 32768

const AT_REMOVEDIR = 512

const AT_STATX_DONT_SYNC = 16384

const AT_STATX_FORCE_SYNC = 8192

const AT_STATX_SYNC_AS_STAT = 0

const AT_STATX_SYNC_TYPE = 24576

const AT_SYMLINK_FOLLOW = 1024

const AT_SYMLINK_NOFOLLOW = 256

const BIG_ENDIAN = 4321

const BITVEC_MXHASH = 0

const BITVEC_NBIT = 0

const BITVEC_NELEM = 0

const BITVEC_NINT = 0

const BITVEC_NPTR = 0

const BITVEC_SZ = 512

const BITVEC_SZELEM = 8

const BITVEC_TELEM = 0

const BITVEC_USIZE = 0

const BTALLOC_ANY = 0

const BTALLOC_EXACT = 1

const BTALLOC_LE = 2

const BTCF_AtLast = 8

const BTCF_Incrblob = 16

const BTCF_Multiple = 32

const BTCF_Pinned = 64

const BTCF_ValidNKey = 2

const BTCF_ValidOvfl = 4

const BTCF_WriteFlag = 1

const BTCURSOR_FIRST_UNINIT = 0

const BTCURSOR_MAX_DEPTH = 20

const BTREE_APPEND = 8

const BTREE_APPLICATION_ID = 8

const BTREE_AUTOVACUUM_FULL = 1

const BTREE_AUTOVACUUM_INCR = 2

const BTREE_AUTOVACUUM_NONE = 0

const BTREE_AUXDELETE = 4

const BTREE_BLOBKEY = 2

const BTREE_BULKLOAD = 1

const BTREE_DATA_VERSION = 15

const BTREE_DEFAULT_CACHE_SIZE = 3

const BTREE_FILE_FORMAT = 2

const BTREE_FORDELETE = 8

const BTREE_FREE_PAGE_COUNT = 0

const BTREE_HINT_RANGE = 0

const BTREE_INCR_VACUUM = 7

const BTREE_INTKEY = 1

const BTREE_LARGEST_ROOT_PAGE = 4

const BTREE_MEMORY = 2

const BTREE_OMIT_JOURNAL = 1

const BTREE_PREFORMAT = 128

const BTREE_SAVEPOSITION = 2

const BTREE_SCHEMA_VERSION = 1

const BTREE_SEEK_EQ = 2

const BTREE_SINGLE = 4

const BTREE_TEXT_ENCODING = 5

const BTREE_UNORDERED = 8

const BTREE_USER_VERSION = 6

const BTREE_WRCSR = 4

const BTS_EXCLUSIVE = 64

const BTS_FAST_SECURE = 12

const BTS_INITIALLY_EMPTY = 16

const BTS_NO_WAL = 32

const BTS_OVERWRITE = 8

const BTS_PAGESIZE_FIXED = 2

const BTS_PENDING = 128

const BTS_READ_ONLY = 1

const BTS_SECURE_DELETE = 4

const BUFSIZ = 1024

const BYTE_ORDER = 1234

const CACHE_STALE = 0

const CC_AND = 24

const CC_BANG = 15

const CC_BOM = 30

const CC_COMMA = 23

const CC_DIGIT = 3

const CC_DOLLAR = 4

const CC_DOT = 26

const CC_EQ = 14

const CC_GT = 13

const CC_ID = 27

const CC_ILLEGAL = 28

const CC_KYWD = 2

const CC_KYWD0 = 1

const CC_LP = 17

const CC_LT = 12

const CC_MINUS = 11

const CC_NUL = 29

const CC_PERCENT = 22

const CC_PIPE = 10

const CC_PLUS = 20

const CC_QUOTE = 8

const CC_QUOTE2 = 9

const CC_RP = 18

const CC_SEMI = 19

const CC_SLASH = 16

const CC_SPACE = 7

const CC_STAR = 21

const CC_TILDA = 25

const CC_VARALPHA = 5

const CC_VARNUM = 6

const CC_X = 0

const CKCNSTRNT_COLUMN = 1

const CKCNSTRNT_ROWID = 2

const CLOCKS_PER_SEC = 1000000

const CLOCK_BOOTTIME = 7

const CLOCK_BOOTTIME_ALARM = 9

const CLOCK_MONOTONIC = 1

const CLOCK_MONOTONIC_COARSE = 6

const CLOCK_MONOTONIC_RAW = 4

const CLOCK_PROCESS_CPUTIME_ID = 2

const CLOCK_REALTIME = 0

const CLOCK_REALTIME_ALARM = 8

const CLOCK_REALTIME_COARSE = 5

const CLOCK_SGI_CYCLE = 10

const CLOCK_TAI = 11

const CLOCK_THREAD_CPUTIME_ID = 3

const CLONE_CHILD_CLEARTID = 2097152

const CLONE_CHILD_SETTID = 16777216

const CLONE_DETACHED = 4194304

const CLONE_FILES = 1024

const CLONE_FS = 512

const CLONE_IO = 2147483648

const CLONE_NEWCGROUP = 33554432

const CLONE_NEWIPC = 134217728

const CLONE_NEWNET = 1073741824

const CLONE_NEWNS = 131072

const CLONE_NEWPID = 536870912

const CLONE_NEWTIME = 128

const CLONE_NEWUSER = 268435456

const CLONE_NEWUTS = 67108864

const CLONE_PARENT = 32768

const CLONE_PARENT_SETTID = 1048576

const CLONE_PIDFD = 4096

const CLONE_PTRACE = 8192

const CLONE_SETTLS = 524288

const CLONE_SIGHAND = 2048

const CLONE_SYSVSEM = 262144

const CLONE_THREAD = 65536

const CLONE_UNTRACED = 8388608

const CLONE_VFORK = 16384

const CLONE_VM = 256

const COLFLAG_BUSY = 256

const COLFLAG_GENERATED = 96

const COLFLAG_HASCOLL = 512

const COLFLAG_HASTYPE = 4

const COLFLAG_HIDDEN = 2

const COLFLAG_NOEXPAND = 1024

const COLFLAG_NOINSERT = 98

const COLFLAG_NOTAVAIL = 128

const COLFLAG_PRIMKEY = 1

const COLFLAG_SORTERREF = 16

const COLFLAG_STORED = 64

const COLFLAG_UNIQUE = 8

const COLFLAG_VIRTUAL = 32

const COLNAME_COLUMN = 4

const COLNAME_DATABASE = 2

const COLNAME_DECLTYPE = 1

const COLNAME_N = 5

const COLNAME_NAME = 0

const COLNAME_TABLE = 3

const COLTYPE_ANY = 1

const COLTYPE_BLOB = 2

const COLTYPE_CUSTOM = 0

const COLTYPE_INT = 3

const COLTYPE_INTEGER = 4

const COLTYPE_REAL = 5

const COLTYPE_TEXT = 6

const CPU_SETSIZE = 1024

const CSIGNAL = 255

const CURSOR_FAULT = 4

const CURSOR_INVALID = 1

const CURSOR_REQUIRESEEK = 3

const CURSOR_SKIPNEXT = 2

const CURSOR_VALID = 0

const CURTYPE_BTREE = 0

const CURTYPE_PSEUDO = 3

const CURTYPE_SORTER = 1

const CURTYPE_VTAB = 2

const DBFLAG_EncodingFixed = 64

const DBFLAG_InternalFunc = 32

const DBFLAG_PreferBuiltin = 2

const DBFLAG_SchemaChange = 1

const DBFLAG_SchemaKnownOk = 16

const DBFLAG_Vacuum = 4

const DBFLAG_VacuumInto = 8

const DBSTAT_PAGE_PADDING_BYTES = 256

const DB_ResetWanted = 8

const DB_SchemaLoaded = 1

const DB_UnresetViews = 2

const DIRECT_MODE = 0

const DN_ACCESS = 1

const DN_ATTRIB = 32

const DN_CREATE = 4

const DN_DELETE = 8

const DN_MODIFY = 2

const DN_MULTISHOT = 2147483648

const DN_RENAME = 16

const DOTLOCK_SUFFIX = ".lock"

const E2BIG = 7

const EACCES = 13

const EADDRINUSE = 98

const EADDRNOTAVAIL = 99

const EADV = 68

const EAFNOSUPPORT = 97

const EAGAIN = 11

const EALREADY = 114

const EBADE = 52

const EBADF = 9

const EBADFD = 77

const EBADMSG = 74

const EBADR = 53

const EBADRQC = 56

const EBADSLT = 57

const EBFONT = 59

const EBUSY = 16

const ECANCELED = 125

const ECHILD = 10

const ECHRNG = 44

const ECOMM = 70

const ECONNABORTED = 103

const ECONNREFUSED = 111

const ECONNRESET = 104

const EDEADLK = 35

const EDEADLOCK = 35

const EDESTADDRREQ = 89

const EDOM = 33

const EDOTDOT = 73

const EDQUOT = 122

const EEXIST = 17

const EFAULT = 14

const EFBIG = 27

const EHOSTDOWN = 112

const EHOSTUNREACH = 113

const EHWPOISON = 133

const EIDRM = 43

const EILSEQ = 84

const EINPROGRESS = 115

const EINTR = 4

const EINVAL = 22

const EIO = 5

const EISCONN = 106

const EISDIR = 21

const EISNAM = 120

const EKEYEXPIRED = 127

const EKEYREJECTED = 129

const EKEYREVOKED = 128

const EL2HLT = 51

const EL2NSYNC = 45

const EL3HLT = 46

const EL3RST = 47

const ELIBACC = 79

const ELIBBAD = 80

const ELIBEXEC = 83

const ELIBMAX = 82

const ELIBSCN = 81

const ELNRNG = 48

const ELOOP = 40

const EMEDIUMTYPE = 124

const EMFILE = 24

const EMLINK = 31

const EMSGSIZE = 90

const EMULTIHOP = 72

const ENAMETOOLONG = 36

const ENAME_NAME = 0

const ENAME_ROWID = 3

const ENAME_SPAN = 1

const ENAME_TAB = 2

const ENAVAIL = 119

const ENETDOWN = 100

const ENETRESET = 102

const ENETUNREACH = 101

const ENFILE = 23

const ENOANO = 55

const ENOBUFS = 105

const ENOCSI = 50

const ENODATA = 61

const ENODEV = 19

const ENOENT = 2

const ENOEXEC = 8

const ENOKEY = 126

const ENOLCK = 37

const ENOLINK = 67

const ENOMEDIUM = 123

const ENOMEM = 12

const ENOMSG = 42

const ENONET = 64

const ENOPKG = 65

const ENOPROTOOPT = 92

const ENOSPC = 28

const ENOSR = 63

const ENOSTR = 60

const ENOSYS = 38

const ENOTBLK = 15

const ENOTCONN = 107

const ENOTDIR = 20

const ENOTEMPTY = 39

const ENOTNAM = 118

const ENOTRECOVERABLE = 131

const ENOTSOCK = 88

const ENOTSUP = 95

const ENOTTY = 25

const ENOTUNIQ = 76

const ENXIO = 6

const EOPNOTSUPP = 95

const EOVERFLOW = 75

const EOWNERDEAD = 130

const EPERM = 1

const EPFNOSUPPORT = 96

const EPIPE = 32

const EPROTO = 71

const EPROTONOSUPPORT = 93

const EPROTOTYPE = 91

const EP_Agg = 16

const EP_CanBeNull = 2097152

const EP_Collate = 512

const EP_Commuted = 1024

const EP_ConstFunc = 1048576

const EP_DblQuoted = 128

const EP_Distinct = 4

const EP_FixedCol = 32

const EP_FromDDL = 1073741824

const EP_FullSize = 131072

const EP_HasFunc = 8

const EP_IfNullRow = 262144

const EP_Immutable = 2

const EP_InfixFunc = 256

const EP_InnerON = 2

const EP_IntValue = 2048

const EP_IsFalse = 536870912

const EP_IsTrue = 268435456

const EP_Leaf = 8388608

const EP_NoReduce = 1

const EP_OuterON = 1

const EP_Propagate = 4194824

const EP_Quoted = 67108864

const EP_Reduced = 16384

const EP_Skip = 8192

const EP_Static = 134217728

const EP_Subquery = 4194304

const EP_Subrtn = 33554432

const EP_TokenOnly = 65536

const EP_Unlikely = 524288

const EP_VarSelect = 64

const EP_Win = 32768

const EP_WinFunc = 16777216

const EP_xIsSelect = 4096

const ERANGE = 34

const EREMCHG = 78

const EREMOTE = 66

const EREMOTEIO = 121

const ERESTART = 85

const ERFKILL = 132

const EROFS = 30

const ESHUTDOWN = 108

const ESOCKTNOSUPPORT = 94

const ESPIPE = 29

const ESRCH = 3

const ESRMNT = 69

const ESTALE = 116

const ESTRPIPE = 86

const ETIME = 62

const ETIMEDOUT = 110

const ETOOMANYREFS = 109

const ETXTBSY = 26

const EU4_EXPR = 2

const EU4_IDX = 1

const EU4_NONE = 0

const EUCLEAN = 117

const EUNATCH = 49

const EUSERS = 87

const EWOULDBLOCK = 11

const EXCLUDED_TABLE_NUMBER = 2

const EXCLUSIVE_LOCK = 4

const EXDEV = 18

const EXFULL = 54

const EXIT_FAILURE = 1

const EXIT_SUCCESS = 0

const EXPRDUP_REDUCE = 1

const EXPR_FULLSIZE = 0

const F2FS_FEATURE_ATOMIC_WRITE = 4

const F2FS_IOCTL_MAGIC = 245

const F2FS_IOC_ABORT_VOLATILE_WRITE = 62725

const F2FS_IOC_COMMIT_ATOMIC_WRITE = 62722

const F2FS_IOC_GET_FEATURES = 2147546380

const F2FS_IOC_START_ATOMIC_WRITE = 62721

const F2FS_IOC_START_VOLATILE_WRITE = 62723

const FALLOC_FL_KEEP_SIZE = 1

const FALLOC_FL_PUNCH_HOLE = 2

const FAPPEND = 1024

const FASYNC = 8192

const FD_CLOEXEC = 1

const FD_SETSIZE = 1024

const FFSYNC = 1052672

const FILENAME_MAX = 4096

const FIOASYNC = 21586

const FIOCLEX = 21585

const FIOGETOWN = 35075

const FIONBIO = 21537

const FIONCLEX = 21584

const FIONREAD = 21531

const FIOQSIZE = 21600

const FIOSETOWN = 35073

const FLAG_SIGNED = 1

const FLAG_STRING = 4

const FNDELAY = 2048

const FNONBLOCK = 2048

const FOPEN_MAX = 1000

const FP_ILOGB0 = -2147483648

const FP_ILOGBNAN = -2147483648

const FP_INFINITE = 1

const FP_NAN = 0

const FP_NORMAL = 4

const FP_SUBNORMAL = 3

const FP_ZERO = 2

const FTS5CSR_EOF = 1

const FTS5CSR_FREE_ZRANK = 16

const FTS5CSR_REQUIRE_CONTENT = 2

const FTS5CSR_REQUIRE_DOCSIZE = 4

const FTS5CSR_REQUIRE_INST = 8

const FTS5CSR_REQUIRE_POSLIST = 64

const FTS5CSR_REQUIRE_RESEEK = 32

const FTS5INDEX_QUERY_DESC = 2

const FTS5INDEX_QUERY_NOOUTPUT = 32

const FTS5INDEX_QUERY_NOTOKENDATA = 128

const FTS5INDEX_QUERY_PREFIX = 1

const FTS5INDEX_QUERY_SCAN = 8

const FTS5INDEX_QUERY_SCANONETERM = 256

const FTS5INDEX_QUERY_SKIPEMPTY = 16

const FTS5INDEX_QUERY_SKIPHASH = 64

const FTS5INDEX_QUERY_TEST_NOIDX = 4

const FTS5TOKEN = 0

const FTS5_AND = 2

const FTS5_AVERAGES_ROWID = 1

const FTS5_BI_MATCH = 1

const FTS5_BI_ORDER_DESC = 128

const FTS5_BI_ORDER_RANK = 32

const FTS5_BI_ORDER_ROWID = 64

const FTS5_BI_RANK = 2

const FTS5_BI_ROWID_EQ = 4

const FTS5_BI_ROWID_GE = 16

const FTS5_BI_ROWID_LE = 8

const FTS5_CARET = 12

const FTS5_COLON = 5

const FTS5_COMMA = 13

const FTS5_CONTENT_EXTERNAL = 2

const FTS5_CONTENT_NONE = 1

const FTS5_CONTENT_NORMAL = 0

const FTS5_CORRUPT = 267

const FTS5_CURRENT_VERSION = 4

const FTS5_CURRENT_VERSION_SECUREDELETE = 5

const FTS5_DATA_DLI_B = 1

const FTS5_DATA_HEIGHT_B = 5

const FTS5_DATA_ID_B = 16

const FTS5_DATA_PADDING = 20

const FTS5_DATA_PAGE_B = 31

const FTS5_DATA_ZERO_PADDING = 8

const FTS5_DEFAULT_AUTOMERGE = 4

const FTS5_DEFAULT_CRISISMERGE = 16

const FTS5_DEFAULT_DELETE_AUTOMERGE = 10

const FTS5_DEFAULT_HASHSIZE = 1048576

const FTS5_DEFAULT_NEARDIST = 10

const FTS5_DEFAULT_PAGE_SIZE = 4050

const FTS5_DEFAULT_RANK = "bm25"

const FTS5_DEFAULT_USERMERGE = 4

const FTS5_DETAIL_COLUMNS = 2

const FTS5_DETAIL_FULL = 0

const FTS5_DETAIL_NONE = 1

const FTS5_EOF = 0

const FTS5_LCP = 7

const FTS5_LP = 10

const FTS5_MAIN_PREFIX = 48

const FTS5_MAX_LEVEL = 64

const FTS5_MAX_PAGE_SIZE = 65536

const FTS5_MAX_PREFIX_INDEXES = 31

const FTS5_MAX_SEGMENT = 2000

const FTS5_MAX_TOKEN_SIZE = 32768

const FTS5_MERGE_NLIST = 16

const FTS5_MINUS = 6

const FTS5_MIN_DLIDX_SIZE = 4

const FTS5_NOINLINE = "SQLITE_NOINLINE"

const FTS5_NOT = 3

const FTS5_OPT_WORK_UNIT = 1000

const FTS5_OR = 1

const FTS5_PATTERN_GLOB = 66

const FTS5_PATTERN_LIKE = 65

const FTS5_PATTERN_NONE = 0

const FTS5_PLAN_MATCH = 1

const FTS5_PLAN_ROWID = 6

const FTS5_PLAN_SCAN = 5

const FTS5_PLAN_SORTED_MATCH = 4

const FTS5_PLAN_SOURCE = 2

const FTS5_PLAN_SPECIAL = 3

const FTS5_PLUS = 14

const FTS5_PORTER_MAX_TOKEN = 64

const FTS5_RANK_NAME = "rank"

const FTS5_RCP = 8

const FTS5_REMOVE_DIACRITICS_COMPLEX = 2

const FTS5_REMOVE_DIACRITICS_NONE = 0

const FTS5_REMOVE_DIACRITICS_SIMPLE = 1

const FTS5_ROWID_NAME = "rowid"

const FTS5_RP = 11

const FTS5_SEGITER_ONETERM = 1

const FTS5_SEGITER_REVERSE = 2

const FTS5_STAR = 15

const FTS5_STMT_DELETE_CONTENT = 5

const FTS5_STMT_DELETE_DOCSIZE = 7

const FTS5_STMT_INSERT_CONTENT = 3

const FTS5_STMT_LOOKUP = 2

const FTS5_STMT_LOOKUP_DOCSIZE = 8

const FTS5_STMT_REPLACE_CONFIG = 9

const FTS5_STMT_REPLACE_CONTENT = 4

const FTS5_STMT_REPLACE_DOCSIZE = 6

const FTS5_STMT_SCAN = 10

const FTS5_STMT_SCAN_ASC = 0

const FTS5_STMT_SCAN_DESC = 1

const FTS5_STRING = 9

const FTS5_STRUCTURE_ROWID = 10

const FTS5_STRUCTURE_V2 = "\xff\x00\x00\x01"

const FTS5_TERM = 4

const FTS5_TOKENIZE_AUX = 8

const FTS5_TOKENIZE_DOCUMENT = 4

const FTS5_TOKENIZE_PREFIX = 2

const FTS5_TOKENIZE_QUERY = 1

const FTS5_TOKEN_COLOCATED = 1

const FTS5_VOCAB_COL = 0

const FTS5_VOCAB_COL_SCHEMA = "term, col, doc, cnt"

const FTS5_VOCAB_INSTANCE = 2

const FTS5_VOCAB_INST_SCHEMA = "term, doc, col, offset"

const FTS5_VOCAB_ROW = 1

const FTS5_VOCAB_ROW_SCHEMA = "term, doc, cnt"

const FTS5_VOCAB_TERM_EQ = 1

const FTS5_VOCAB_TERM_GE = 2

const FTS5_VOCAB_TERM_LE = 4

const FTS5_WORK_UNIT = 64

const FULLY_WITHIN = 2

const FUNC_PERFECT_MATCH = 6

const F_ADD_SEALS = 1033

const F_CANCELLK = 1029

const F_DUPFD = 0

const F_DUPFD_CLOEXEC = 1030

const F_GETFD = 1

const F_GETFL = 3

const F_GETLEASE = 1025

const F_GETLK = 5

const F_GETOWN = 9

const F_GETOWNER_UIDS = 17

const F_GETOWN_EX = 16

const F_GETPIPE_SZ = 1032

const F_GETSIG = 11

const F_GET_FILE_RW_HINT = 1037

const F_GET_RW_HINT = 1035

const F_GET_SEALS = 1034

const F_LOCK = 1

const F_NOTIFY = 1026

const F_OFD_GETLK = 36

const F_OFD_SETLK = 37

const F_OFD_SETLKW = 38

const F_OK = 0

const F_OWNER_GID = 2

const F_OWNER_PGRP = 2

const F_OWNER_PID = 1

const F_OWNER_TID = 0

const F_RDLCK = 0

const F_SEAL_FUTURE_WRITE = 16

const F_SEAL_GROW = 4

const F_SEAL_SEAL = 1

const F_SEAL_SHRINK = 2

const F_SEAL_WRITE = 8

const F_SETFD = 2

const F_SETFL = 4

const F_SETLEASE = 1024

const F_SETLK = 6

const F_SETLKW = 7

const F_SETOWN = 8

const F_SETOWN_EX = 15

const F_SETPIPE_SZ = 1031

const F_SETSIG = 10

const F_SET_FILE_RW_HINT = 1038

const F_SET_RW_HINT = 1036

const F_TEST = 3

const F_TLOCK = 2

const F_ULOCK = 0

const F_UNLCK = 2

const F_WRLCK = 1

const GCC_VERSION = 12002000

const GEOPOLY_PI = 3.141592653589793

const HASHSIZE = 97

const HASHTABLE_HASH_1 = 383

const HASHTABLE_NPAGE = 4096

const HASHTABLE_NPAGE_ONE = 4096

const HASHTABLE_NSLOT = 8192

const HAVE_FCHOWN = 1

const HAVE_FULLFSYNC = 0

const HAVE_GETHOSTUUID = 0

const HAVE_LSTAT = 1

const HAVE_MREMAP = 1

const HAVE_PREAD = 1

const HAVE_PWRITE = 1

const HAVE_READLINK = 1

const HAVE_USLEEP = 1

const HUGE = 0

const HUGE_VALF = 0

const INCRINIT_NORMAL = 0

const INCRINIT_ROOT = 2

const INCRINIT_TASK = 1

const INFINITY = 0

const INITFLAG_AlterAdd = 3

const INITFLAG_AlterDrop = 2

const INITFLAG_AlterMask = 3

const INITFLAG_AlterRename = 1

const INLINEFUNC_affinity = 4

const INLINEFUNC_coalesce = 0

const INLINEFUNC_expr_compare = 3

const INLINEFUNC_expr_implies_expr = 2

const INLINEFUNC_iif = 5

const INLINEFUNC_implies_nonnull_row = 1

const INLINEFUNC_sqlite_offset = 6

const INLINEFUNC_unlikely = 99

const INTERFACE = 1

const IN_INDEX_EPH = 2

const IN_INDEX_INDEX_ASC = 3

const IN_INDEX_INDEX_DESC = 4

const IN_INDEX_LOOP = 4

const IN_INDEX_MEMBERSHIP = 2

const IN_INDEX_NOOP = 5

const IN_INDEX_NOOP_OK = 1

const IN_INDEX_ROWID = 1

const ITIMER_PROF = 2

const ITIMER_REAL = 0

const ITIMER_VIRTUAL = 1

const IsStat4 = 1

const JEACH_ATOM = 3

const JEACH_FULLKEY = 6

const JEACH_ID = 4

const JEACH_JSON = 8

const JEACH_KEY = 0

const JEACH_PARENT = 5

const JEACH_PATH = 7

const JEACH_ROOT = 9

const JEACH_TYPE = 2

const JEACH_VALUE = 1

const JEDIT_DEL = 1

const JEDIT_INS = 3

const JEDIT_REPL = 2

const JEDIT_SET = 4

const JSONB_ARRAY = 11

const JSONB_FALSE = 2

const JSONB_FLOAT = 5

const JSONB_FLOAT5 = 6

const JSONB_INT = 3

const JSONB_INT5 = 4

const JSONB_NULL = 0

const JSONB_OBJECT = 12

const JSONB_TEXT = 7

const JSONB_TEXT5 = 9

const JSONB_TEXTJ = 8

const JSONB_TEXTRAW = 10

const JSONB_TRUE = 1

const JSON_ABPATH = 3

const JSON_BLOB = 8

const JSON_CACHE_ID = -429938

const JSON_CACHE_SIZE = 4

const JSON_EDITABLE = 1

const JSON_INVALID_CHAR = 629145

const JSON_ISSET = 4

const JSON_JSON = 1

const JSON_KEEPERROR = 2

const JSON_LOOKUP_ERROR = 4294967295

const JSON_LOOKUP_NOTFOUND = 4294967294

const JSON_LOOKUP_PATHERROR = 4294967293

const JSON_MAX_DEPTH = 1000

const JSON_MERGE_BADPATCH = 2

const JSON_MERGE_BADTARGET = 1

const JSON_MERGE_OK = 0

const JSON_MERGE_OOM = 3

const JSON_SQL = 2

const JSON_SUBTYPE = 74

const JSTRING_ERR = 4

const JSTRING_MALFORMED = 2

const JSTRING_OOM = 1

const JT_CROSS = 2

const JT_ERROR = 128

const JT_INNER = 1

const JT_LEFT = 8

const JT_LTORJ = 64

const JT_NATURAL = 4

const JT_OUTER = 32

const JT_RIGHT = 16

const KEYINFO_ORDER_BIGNULL = 2

const KEYINFO_ORDER_DESC = 1

const LEGACY_SCHEMA_TABLE = "sqlite_master"

const LEGACY_TEMP_SCHEMA_TABLE = "sqlite_temp_master"

const LITTLE_ENDIAN = 1234

const LOCATE_NOERR = 2

const LOCATE_VIEW = 1

const LONGDOUBLE_TYPE = 0

const LOOKASIDE_SMALL = 128

const L_INCR = 1

const L_SET = 0

const L_XTND = 2

const L_ctermid = 20

const L_cuserid = 20

const L_tmpnam = 20

const M10d_Any = 1

const M10d_No = 2

const M10d_Yes = 0

const MADV_COLD = 20

const MADV_DODUMP = 17

const MADV_DOFORK = 11

const MADV_DONTDUMP = 16

const MADV_DONTFORK = 10

const MADV_DONTNEED = 4

const MADV_FREE = 8

const MADV_HUGEPAGE = 14

const MADV_HWPOISON = 100

const MADV_KEEPONFORK = 19

const MADV_MERGEABLE = 12

const MADV_NOHUGEPAGE = 15

const MADV_NORMAL = 0

const MADV_PAGEOUT = 21

const MADV_RANDOM = 1

const MADV_REMOVE = 9

const MADV_SEQUENTIAL = 2

const MADV_SOFT_OFFLINE = 101

const MADV_UNMERGEABLE = 13

const MADV_WILLNEED = 3

const MADV_WIPEONFORK = 18

const MAP_32BIT = 64

const MAP_ANON = 32

const MAP_ANONYMOUS = 32

const MAP_DENYWRITE = 2048

const MAP_EXECUTABLE = 4096

const MAP_FAILED = -1

const MAP_FILE = 0

const MAP_FIXED = 16

const MAP_FIXED_NOREPLACE = 1048576

const MAP_GROWSDOWN = 256

const MAP_HUGETLB = 262144

const MAP_HUGE_16GB = 2281701376

const MAP_HUGE_16KB = 939524096

const MAP_HUGE_16MB = 1610612736

const MAP_HUGE_1GB = 2013265920

const MAP_HUGE_1MB = 1342177280

const MAP_HUGE_256MB = 1879048192

const MAP_HUGE_2GB = 2080374784

const MAP_HUGE_2MB = 1409286144

const MAP_HUGE_32MB = 1677721600

const MAP_HUGE_512KB = 1275068416

const MAP_HUGE_512MB = 1946157056

const MAP_HUGE_64KB = 1073741824

const MAP_HUGE_8MB = 1543503872

const MAP_HUGE_MASK = 63

const MAP_HUGE_SHIFT = 26

const MAP_LOCKED = 8192

const MAP_NONBLOCK = 65536

const MAP_NORESERVE = 16384

const MAP_POPULATE = 32768

const MAP_PRIVATE = 2

const MAP_SHARED = 1

const MAP_SHARED_VALIDATE = 3

const MAP_STACK = 131072

const MAP_SYNC = 524288

const MAP_TYPE = 15

const MATH_ERREXCEPT = 2

const MATH_ERRNO = 1

const MAX_HANDLE_SZ = 128

const MAX_PATHNAME = 512

const MAX_SECTOR_SIZE = 65536

const MB_CUR_MAX = 0

const MCL_CURRENT = 1

const MCL_FUTURE = 2

const MCL_ONFAULT = 4

const MEMJOURNAL_DFLT_FILECHUNKSIZE = 1024

const MEMTYPE_HEAP = 1

const MEMTYPE_LOOKASIDE = 2

const MEMTYPE_PCACHE = 4

const MEM_AffMask = 63

const MEM_Agg = 32768

const MEM_Blob = 16

const MEM_Cleared = 256

const MEM_Dyn = 4096

const MEM_Ephem = 16384

const MEM_FromBind = 64

const MEM_Int = 4

const MEM_IntReal = 32

const MEM_Null = 1

const MEM_Real = 8

const MEM_Static = 8192

const MEM_Str = 2

const MEM_Subtype = 2048

const MEM_Term = 512

const MEM_TypeMask = 3519

const MEM_Undefined = 0

const MEM_Zero = 1024

const MFD_ALLOW_SEALING = 2

const MFD_CLOEXEC = 1

const MFD_HUGETLB = 4

const MLOCK_ONFAULT = 1

const MREMAP_DONTUNMAP = 4

const MREMAP_FIXED = 2

const MREMAP_MAYMOVE = 1

const MSVC_VERSION = 0

const MS_ASYNC = 1

const MS_INVALIDATE = 2

const MS_SYNC = 4

const M_1_PI = 0

const M_2_PI = 0

const M_2_SQRTPI = 0

const M_E = 0

const M_LN10 = 0

const M_LN2 = 0

const M_LOG10E = 0

const M_LOG2E = 0

const M_PI = 3.141592653589793

const M_PI_2 = 0

const M_PI_4 = 0

const M_SQRT1_2 = 0

const M_SQRT2 = 0

const NAN = 0

const NB = 3

const NC_AllowAgg = 1

const NC_AllowWin = 16384

const NC_Complex = 8192

const NC_FromDDL = 262144

const NC_GenCol = 8

const NC_HasAgg = 16

const NC_HasWin = 32768

const NC_IdxExpr = 32

const NC_InAggFunc = 131072

const NC_IsCheck = 4

const NC_IsDDL = 65536

const NC_MinMaxAgg = 4096

const NC_NoSelect = 524288

const NC_OrderAgg = 134217728

const NC_PartIdx = 2

const NC_SelfRef = 46

const NC_Subquery = 64

const NC_UAggInfo = 256

const NC_UBaseReg = 1024

const NC_UEList = 128

const NC_UUpsert = 512

const NC_Where = 1048576

const NDEBUG = 1

const NN = 1

const NOT_WITHIN = 0

const NO_LOCK = 0

const N_6PACK = 7

const N_AX25 = 5

const N_CAIF = 20

const N_GIGASET_M101 = 16

const N_GSM0710 = 21

const N_HCI = 15

const N_HDLC = 13

const N_IRDA = 11

const N_MASC = 8

const N_MOUSE = 2

const N_NCI = 25

const N_NULL = 27

const N_OR_COST = 3

const N_PPP = 3

const N_PPS = 18

const N_PROFIBUS_FDL = 10

const N_R3964 = 9

const N_SLCAN = 17

const N_SLIP = 1

const N_SMSBLOCK = 12

const N_SORT_BUCKET = 32

const N_SPEAKUP = 26

const N_STATEMENT = 8

const N_STRIP = 4

const N_SYNC_PPP = 14

const N_TI_WL = 22

const N_TRACEROUTER = 24

const N_TRACESINK = 23

const N_TTY = 0

const N_V253 = 19

const N_X25 = 6

const OE_Abort = 2

const OE_Cascade = 10

const OE_Default = 11

const OE_Fail = 3

const OE_Ignore = 4

const OE_None = 0

const OE_Replace = 5

const OE_Restrict = 7

const OE_Rollback = 1

const OE_SetDflt = 9

const OE_SetNull = 8

const OE_Update = 6

const OMIT_TEMPDB = 0

const ONEPASS_MULTI = 2

const ONEPASS_OFF = 0

const ONEPASS_SINGLE = 1

const OPFLAG_APPEND = 8

const OPFLAG_AUXDELETE = 4

const OPFLAG_BULKCSR = 1

const OPFLAG_BYTELENARG = 192

const OPFLAG_EPHEM = 1

const OPFLAG_FORDELETE = 8

const OPFLAG_ISNOOP = 64

const OPFLAG_ISUPDATE = 4

const OPFLAG_LASTROWID = 32

const OPFLAG_LENGTHARG = 64

const OPFLAG_NCHANGE = 1

const OPFLAG_NOCHNG = 1

const OPFLAG_NOCHNG_MAGIC = 109

const OPFLAG_P2ISREG = 16

const OPFLAG_PERMUTE = 1

const OPFLAG_PREFORMAT = 128

const OPFLAG_SAVEPOSITION = 2

const OPFLAG_SEEKEQ = 2

const OPFLAG_TYPEOFARG = 128

const OPFLAG_USESEEKRESULT = 16

const OPFLG_IN1 = 2

const OPFLG_IN2 = 4

const OPFLG_IN3 = 8

const OPFLG_JUMP = 1

const OPFLG_JUMP0 = 128

const OPFLG_NCYCLE = 64

const OPFLG_OUT2 = 16

const OPFLG_OUT3 = 32

const OP_Abortable = 189

const OP_Add = 106

const OP_AddImm = 86

const OP_Affinity = 96

const OP_AggFinal = 165

const OP_AggInverse = 161

const OP_AggStep = 162

const OP_AggStep1 = 163

const OP_AggValue = 164

const OP_And = 44

const OP_AutoCommit = 1

const OP_BeginSubrtn = 74

const OP_BitAnd = 102

const OP_BitNot = 114

const OP_BitOr = 103

const OP_Blob = 77

const OP_Cast = 88

const OP_Checkpoint = 3

const OP_Clear = 145

const OP_Close = 122

const OP_ClrSubtype = 180

const OP_CollSeq = 85

const OP_Column = 94

const OP_ColumnsUsed = 123

const OP_Compare = 90

const OP_Concat = 111

const OP_Copy = 80

const OP_Count = 98

const OP_CreateBtree = 147

const OP_CursorHint = 185

const OP_CursorLock = 167

const OP_CursorUnlock = 168

const OP_DecrJumpZero = 61

const OP_DeferredSeek = 141

const OP_Delete = 130

const OP_Destroy = 144

const OP_Divide = 109

const OP_DropIndex = 152

const OP_DropTable = 151

const OP_DropTrigger = 154

const OP_ElseEq = 58

const OP_EndCoroutine = 68

const OP_Eq = 53

const OP_Expire = 166

const OP_Explain = 188

const OP_Filter = 64

const OP_FilterAdd = 183

const OP_FinishSeek = 143

const OP_FkCheck = 83

const OP_FkCounter = 158

const OP_FkIfZero = 49

const OP_Found = 29

const OP_Function = 66

const OP_Ge = 57

const OP_GetSubtype = 181

const OP_Gosub = 10

const OP_Goto = 9

const OP_Gt = 54

const OP_Halt = 70

const OP_HaltIfNull = 69

const OP_IdxDelete = 140

const OP_IdxGE = 45

const OP_IdxGT = 41

const OP_IdxInsert = 138

const OP_IdxLE = 40

const OP_IdxLT = 42

const OP_IdxRowid = 142

const OP_If = 16

const OP_IfNoHope = 26

const OP_IfNot = 17

const OP_IfNotOpen = 25

const OP_IfNotZero = 60

const OP_IfNullRow = 20

const OP_IfPos = 59

const OP_IfSizeBetween = 33

const OP_IncrVacuum = 62

const OP_Init = 8

const OP_InitCoroutine = 11

const OP_Insert = 128

const OP_Int64 = 72

const OP_IntCopy = 82

const OP_Integer = 71

const OP_IntegrityCk = 155

const OP_IsNull = 50

const OP_IsTrue = 91

const OP_IsType = 18

const OP_JournalMode = 4

const OP_Jump = 14

const OP_Last = 32

const OP_Le = 55

const OP_LoadAnalysis = 150

const OP_Lt = 56

const OP_MakeRecord = 97

const OP_MaxPgcnt = 179

const OP_MemMax = 159

const OP_Move = 79

const OP_Multiply = 108

const OP_MustBeInt = 13

const OP_Ne = 52

const OP_NewRowid = 127

const OP_Next = 39

const OP_NoConflict = 27

const OP_Noop = 187

const OP_Not = 19

const OP_NotExists = 31

const OP_NotFound = 28

const OP_NotNull = 51

const OP_Null = 75

const OP_NullRow = 136

const OP_Offset = 93

const OP_OffsetLimit = 160

const OP_Once = 15

const OP_OpenAutoindex = 116

const OP_OpenDup = 115

const OP_OpenEphemeral = 118

const OP_OpenPseudo = 121

const OP_OpenRead = 112

const OP_OpenWrite = 113

const OP_Or = 43

const OP_Pagecount = 178

const OP_Param = 157

const OP_ParseSchema = 149

const OP_Permutation = 89

const OP_Prev = 38

const OP_Program = 48

const OP_PureFunc = 65

const OP_ReadCookie = 99

const OP_Real = 153

const OP_RealAffinity = 87

const OP_ReleaseReg = 186

const OP_Remainder = 110

const OP_ReopenIdx = 101

const OP_ResetCount = 131

const OP_ResetSorter = 146

const OP_ResultRow = 84

const OP_Return = 67

const OP_Rewind = 36

const OP_RowCell = 129

const OP_RowData = 134

const OP_RowSetAdd = 156

const OP_RowSetRead = 46

const OP_RowSetTest = 47

const OP_Rowid = 135

const OP_SCopy = 81

const OP_Savepoint = 0

const OP_SeekEnd = 137

const OP_SeekGE = 23

const OP_SeekGT = 24

const OP_SeekHit = 125

const OP_SeekLE = 22

const OP_SeekLT = 21

const OP_SeekRowid = 30

const OP_SeekScan = 124

const OP_Sequence = 126

const OP_SequenceTest = 120

const OP_SetCookie = 100

const OP_SetSubtype = 182

const OP_ShiftLeft = 104

const OP_ShiftRight = 105

const OP_SoftNull = 76

const OP_Sort = 35

const OP_SorterCompare = 132

const OP_SorterData = 133

const OP_SorterInsert = 139

const OP_SorterNext = 37

const OP_SorterOpen = 119

const OP_SorterSort = 34

const OP_SqlExec = 148

const OP_String = 73

const OP_String8 = 117

const OP_Subtract = 107

const OP_TableLock = 169

const OP_Trace = 184

const OP_Transaction = 2

const OP_TypeCheck = 95

const OP_VBegin = 170

const OP_VCheck = 174

const OP_VColumn = 176

const OP_VCreate = 171

const OP_VDestroy = 172

const OP_VFilter = 6

const OP_VInitIn = 175

const OP_VNext = 63

const OP_VOpen = 173

const OP_VRename = 177

const OP_VUpdate = 7

const OP_Vacuum = 5

const OP_Variable = 78

const OP_Yield = 12

const OP_ZeroOrNull = 92

const OS_VXWORKS = 0

const O_ACCMODE = 2097155

const O_APPEND = 1024

const O_ASYNC = 8192

const O_BINARY = 0

const O_CLOEXEC = 524288

const O_CREAT = 64

const O_DIRECT = 16384

const O_DIRECTORY = 65536

const O_DSYNC = 4096

const O_EXCL = 128

const O_EXEC = 2097152

const O_LARGEFILE = 32768

const O_NDELAY = 2048

const O_NOATIME = 262144

const O_NOCTTY = 256

const O_NOFOLLOW = 131072

const O_NONBLOCK = 2048

const O_PATH = 2097152

const O_RDONLY = 0

const O_RDWR = 2

const O_RSYNC = 1052672

const O_SEARCH = 2097152

const O_SYNC = 1052672

const O_TMPFILE = 4259840

const O_TRUNC = 512

const O_TTY_INIT = 0

const O_WRONLY = 1

const P4_COLLSEQ = -2

const P4_DYNAMIC = -6

const P4_EXPR = -9

const P4_FREE_IF_LE = -6

const P4_FUNCCTX = -15

const P4_FUNCDEF = -7

const P4_INT32 = -3

const P4_INT64 = -13

const P4_INTARRAY = -14

const P4_KEYINFO = -8

const P4_MEM = -10

const P4_NOTUSED = 0

const P4_REAL = -12

const P4_STATIC = -1

const P4_SUBPROGRAM = -4

const P4_TABLE = -5

const P4_TABLEREF = -16

const P4_TRANSIENT = 0

const P4_VTAB = -11

const P5_ConstraintCheck = 3

const P5_ConstraintFK = 4

const P5_ConstraintNotNull = 1

const P5_ConstraintUnique = 2

const PAGER_CACHESPILL = 32

const PAGER_CKPT_FULLFSYNC = 16

const PAGER_ERROR = 6

const PAGER_FLAGS_MASK = 56

const PAGER_FULLFSYNC = 8

const PAGER_GET_NOCONTENT = 1

const PAGER_GET_READONLY = 2

const PAGER_JOURNALMODE_DELETE = 0

const PAGER_JOURNALMODE_MEMORY = 4

const PAGER_JOURNALMODE_OFF = 2

const PAGER_JOURNALMODE_PERSIST = 1

const PAGER_JOURNALMODE_QUERY = -1

const PAGER_JOURNALMODE_TRUNCATE = 3

const PAGER_JOURNALMODE_WAL = 5

const PAGER_LOCKINGMODE_EXCLUSIVE = 1

const PAGER_LOCKINGMODE_NORMAL = 0

const PAGER_LOCKINGMODE_QUERY = -1

const PAGER_MEMORY = 2

const PAGER_OMIT_JOURNAL = 1

const PAGER_OPEN = 0

const PAGER_READER = 1

const PAGER_STAT_HIT = 0

const PAGER_STAT_MISS = 1

const PAGER_STAT_SPILL = 3

const PAGER_STAT_WRITE = 2

const PAGER_SYNCHRONOUS_EXTRA = 4

const PAGER_SYNCHRONOUS_FULL = 3

const PAGER_SYNCHRONOUS_MASK = 7

const PAGER_SYNCHRONOUS_NORMAL = 2

const PAGER_SYNCHRONOUS_OFF = 1

const PAGER_WRITER_CACHEMOD = 3

const PAGER_WRITER_DBMOD = 4

const PAGER_WRITER_FINISHED = 5

const PAGER_WRITER_LOCKED = 2

const PARSE_MODE_DECLARE_VTAB = 1

const PARSE_MODE_NORMAL = 0

const PARSE_MODE_RENAME = 2

const PARSE_MODE_UNMAP = 3

const PARTLY_WITHIN = 1

const PCACHE1_MIGHT_USE_GROUP_MUTEX = 1

const PCACHE_DIRTYLIST_ADD = 2

const PCACHE_DIRTYLIST_FRONT = 3

const PCACHE_DIRTYLIST_REMOVE = 1

const PDP_ENDIAN = 3412

const PENDING_BYTE = 0

const PENDING_LOCK = 3

const PGHDR_CLEAN = 1

const PGHDR_DIRTY = 2

const PGHDR_DONT_WRITE = 16

const PGHDR_MMAP = 32

const PGHDR_NEED_SYNC = 8

const PGHDR_WAL_APPEND = 64

const PGHDR_WRITEABLE = 4

const POSIX_CLOSE_RESTART = 0

const POSIX_FADV_DONTNEED = 4

const POSIX_FADV_NOREUSE = 5

const POSIX_FADV_NORMAL = 0

const POSIX_FADV_RANDOM = 1

const POSIX_FADV_SEQUENTIAL = 2

const POSIX_FADV_WILLNEED = 3

const POSIX_MADV_DONTNEED = 4

const POSIX_MADV_NORMAL = 0

const POSIX_MADV_RANDOM = 1

const POSIX_MADV_SEQUENTIAL = 2

const POSIX_MADV_WILLNEED = 3

const PREFERRED_SCHEMA_TABLE = "sqlite_schema"

const PREFERRED_TEMP_SCHEMA_TABLE = "sqlite_temp_schema"

const PROT_EXEC = 4

const PROT_GROWSDOWN = 16777216

const PROT_GROWSUP = 33554432

const PROT_NONE = 0

const PROT_READ = 1

const PROT_WRITE = 2

const PTF_INTKEY = 1

const PTF_LEAF = 8

const PTF_LEAFDATA = 4

const PTF_ZERODATA = 2

const PTHREAD_BARRIER_SERIAL_THREAD = -1

const PTHREAD_CANCELED = -1

const PTHREAD_CANCEL_ASYNCHRONOUS = 1

const PTHREAD_CANCEL_DEFERRED = 0

const PTHREAD_CANCEL_DISABLE = 1

const PTHREAD_CANCEL_ENABLE = 0

const PTHREAD_CANCEL_MASKED = 2

const PTHREAD_CREATE_DETACHED = 1

const PTHREAD_CREATE_JOINABLE = 0

const PTHREAD_EXPLICIT_SCHED = 1

const PTHREAD_INHERIT_SCHED = 0

const PTHREAD_MUTEX_DEFAULT = 0

const PTHREAD_MUTEX_ERRORCHECK = 2

const PTHREAD_MUTEX_NORMAL = 0

const PTHREAD_MUTEX_RECURSIVE = 1

const PTHREAD_MUTEX_ROBUST = 1

const PTHREAD_MUTEX_STALLED = 0

const PTHREAD_ONCE_INIT = 0

const PTHREAD_PRIO_INHERIT = 1

const PTHREAD_PRIO_NONE = 0

const PTHREAD_PRIO_PROTECT = 2

const PTHREAD_PROCESS_PRIVATE = 0

const PTHREAD_PROCESS_SHARED = 1

const PTHREAD_SCOPE_PROCESS = 1

const PTHREAD_SCOPE_SYSTEM = 0

const PTRMAP_BTREE = 5

const PTRMAP_FREEPAGE = 2

const PTRMAP_OVERFLOW1 = 3

const PTRMAP_OVERFLOW2 = 4

const PTRMAP_ROOTPAGE = 1

const P_tmpdir = "/tmp"

const PragFlg_NeedSchema = 1

const PragFlg_NoColumns = 2

const PragFlg_NoColumns1 = 4

const PragFlg_ReadOnly = 8

const PragFlg_Result0 = 16

const PragFlg_Result1 = 32

const PragFlg_SchemaOpt = 64

const PragFlg_SchemaReq = 128

const PragTyp_ACTIVATE_EXTENSIONS = 0

const PragTyp_ANALYSIS_LIMIT = 1

const PragTyp_AUTO_VACUUM = 3

const PragTyp_BUSY_TIMEOUT = 5

const PragTyp_CACHE_SIZE = 6

const PragTyp_CACHE_SPILL = 7

const PragTyp_CASE_SENSITIVE_LIKE = 8

const PragTyp_COLLATION_LIST = 9

const PragTyp_COMPILE_OPTIONS = 10

const PragTyp_DATABASE_LIST = 12

const PragTyp_DATA_STORE_DIRECTORY = 11

const PragTyp_DEFAULT_CACHE_SIZE = 13

const PragTyp_ENCODING = 14

const PragTyp_FLAG = 4

const PragTyp_FOREIGN_KEY_CHECK = 15

const PragTyp_FOREIGN_KEY_LIST = 16

const PragTyp_FUNCTION_LIST = 17

const PragTyp_HARD_HEAP_LIMIT = 18

const PragTyp_HEADER_VALUE = 2

const PragTyp_INCREMENTAL_VACUUM = 19

const PragTyp_INDEX_INFO = 20

const PragTyp_INDEX_LIST = 21

const PragTyp_INTEGRITY_CHECK = 22

const PragTyp_JOURNAL_MODE = 23

const PragTyp_JOURNAL_SIZE_LIMIT = 24

const PragTyp_LOCKING_MODE = 26

const PragTyp_LOCK_PROXY_FILE = 25

const PragTyp_LOCK_STATUS = 44

const PragTyp_MMAP_SIZE = 28

const PragTyp_MODULE_LIST = 29

const PragTyp_OPTIMIZE = 30

const PragTyp_PAGE_COUNT = 27

const PragTyp_PAGE_SIZE = 31

const PragTyp_PRAGMA_LIST = 32

const PragTyp_SECURE_DELETE = 33

const PragTyp_SHRINK_MEMORY = 34

const PragTyp_SOFT_HEAP_LIMIT = 35

const PragTyp_STATS = 45

const PragTyp_SYNCHRONOUS = 36

const PragTyp_TABLE_INFO = 37

const PragTyp_TABLE_LIST = 38

const PragTyp_TEMP_STORE = 39

const PragTyp_TEMP_STORE_DIRECTORY = 40

const PragTyp_THREADS = 41

const PragTyp_WAL_AUTOCHECKPOINT = 42

const PragTyp_WAL_CHECKPOINT = 43

const RAND_MAX = 2147483647

const RBU_CREATE_STATE = "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"

const RBU_DELETE = 2

const RBU_ENABLE_DELTA_CKSUM = 0

const RBU_EXCLUSIVE_CHECKPOINT = "rbu_exclusive_checkpoint"

const RBU_IDX_DELETE = 4

const RBU_IDX_INSERT = 5

const RBU_INSERT = 1

const RBU_PK_EXTERNAL = 3

const RBU_PK_IPK = 2

const RBU_PK_NONE = 1

const RBU_PK_NOTABLE = 0

const RBU_PK_VTAB = 5

const RBU_PK_WITHOUT_ROWID = 4

const RBU_REPLACE = 3

const RBU_STAGE_CAPTURE = 3

const RBU_STAGE_CKPT = 4

const RBU_STAGE_DONE = 5

const RBU_STAGE_MOVE = 2

const RBU_STAGE_OAL = 1

const RBU_STATE_CKPT = 6

const RBU_STATE_COOKIE = 7

const RBU_STATE_DATATBL = 10

const RBU_STATE_IDX = 3

const RBU_STATE_OALSZ = 8

const RBU_STATE_PHASEONESTEP = 9

const RBU_STATE_PROGRESS = 5

const RBU_STATE_ROW = 4

const RBU_STATE_STAGE = 1

const RBU_STATE_TBL = 2

const RBU_UPDATE = 6

const RBU_ZIPVFS_CTRL_FILE_POINTER = 230439

const READMARK_NOT_USED = 4294967295

const READ_LOCK = 1

const RESERVED_BYTE = 1

const RESERVED_LOCK = 2

const RNDAWAY = 0

const RNDTOWARDS = 0

const ROWSET_ALLOCATION_SIZE = 1024

const ROWSET_ENTRY_PER_CHUNK = 1016

const ROWSET_NEXT = 2

const ROWSET_SORTED = 1

const RTLD_DI_LINKMAP = 2

const RTLD_GLOBAL = 256

const RTLD_LAZY = 1

const RTLD_LOCAL = 0

const RTLD_NEXT = -1

const RTLD_NODELETE = 4096

const RTLD_NOLOAD = 4

const RTLD_NOW = 2

const RTREE_CACHE_SZ = 5

const RTREE_CHECK_MAX_ERROR = 100

const RTREE_COORD_INT32 = 1

const RTREE_COORD_REAL32 = 0

const RTREE_DEFAULT_ROWEST = 1048576

const RTREE_EQ = 65

const RTREE_FALSE = 64

const RTREE_GE = 68

const RTREE_GT = 69

const RTREE_LE = 66

const RTREE_LT = 67

const RTREE_MATCH = 70

const RTREE_MAXCELLS = 51

const RTREE_MAX_AUX_COLUMN = 100

const RTREE_MAX_DEPTH = 40

const RTREE_MAX_DIMENSIONS = 5

const RTREE_MIN_ROWEST = 100

const RTREE_QUERY = 71

const RTREE_TRUE = 63

const RTREE_ZERO = 0

const RWF_WRITE_LIFE_NOT_SET = 0

const RWH_WRITE_LIFE_EXTREME = 5

const RWH_WRITE_LIFE_LONG = 4

const RWH_WRITE_LIFE_MEDIUM = 3

const RWH_WRITE_LIFE_NONE = 1

const RWH_WRITE_LIFE_SHORT = 2

const R_OK = 4

const SAVEPOINT_BEGIN = 0

const SAVEPOINT_RELEASE = 1

const SAVEPOINT_ROLLBACK = 2

const SCHED_BATCH = 3

const SCHED_DEADLINE = 6

const SCHED_FIFO = 1

const SCHED_IDLE = 5

const SCHED_OTHER = 0

const SCHED_RESET_ON_FORK = 1073741824

const SCHED_RR = 2

const SCHEMA_ROOT = 1

const SEEK_DATA = 3

const SEEK_HOLE = 4

const SESSIONS_ROWID = "_rowid_"

const SESSIONS_STRM_CHUNK_SIZE = 1024

const SESSION_MAX_BUFFER_SZ = 2147483391

const SESSION_UPDATE_CACHE_SZ = 12

const SF_Aggregate = 8

const SF_All = 2

const SF_ComplexResult = 262144

const SF_Compound = 256

const SF_Converted = 65536

const SF_CopyCte = 67108864

const SF_Correlated = 536870912

const SF_Distinct = 1

const SF_Expanded = 64

const SF_FixedLimit = 16384

const SF_HasAgg = 16

const SF_HasTypeInfo = 128

const SF_IncludeHidden = 131072

const SF_MaybeConvert = 32768

const SF_MinMaxAgg = 4096

const SF_MultiPart = 33554432

const SF_MultiValue = 1024

const SF_NestedFrom = 2048

const SF_NoopOrderBy = 4194304

const SF_OrderByReqd = 134217728

const SF_PushDown = 16777216

const SF_Recursive = 8192

const SF_Resolved = 4

const SF_UFSrcCheck = 8388608

const SF_UpdateFrom = 268435456

const SF_UsesEphemeral = 32

const SF_Values = 512

const SF_View = 2097152

const SF_WhereBegin = 524288

const SF_WinRewrite = 1048576

const SHARED_FIRST = 2

const SHARED_LOCK = 1

const SHARED_SIZE = 510

const SIOCADDDLCI = 35200

const SIOCADDMULTI = 35121

const SIOCADDRT = 35083

const SIOCATMARK = 35077

const SIOCDARP = 35155

const SIOCDELDLCI = 35201

const SIOCDELMULTI = 35122

const SIOCDELRT = 35084

const SIOCDEVPRIVATE = 35312

const SIOCDIFADDR = 35126

const SIOCDRARP = 35168

const SIOCGARP = 35156

const SIOCGIFADDR = 35093

const SIOCGIFBR = 35136

const SIOCGIFBRDADDR = 35097

const SIOCGIFCONF = 35090

const SIOCGIFCOUNT = 35128

const SIOCGIFDSTADDR = 35095

const SIOCGIFENCAP = 35109

const SIOCGIFFLAGS = 35091

const SIOCGIFHWADDR = 35111

const SIOCGIFINDEX = 35123

const SIOCGIFMAP = 35184

const SIOCGIFMEM = 35103

const SIOCGIFMETRIC = 35101

const SIOCGIFMTU = 35105

const SIOCGIFNAME = 35088

const SIOCGIFNETMASK = 35099

const SIOCGIFPFLAGS = 35125

const SIOCGIFSLAVE = 35113

const SIOCGIFTXQLEN = 35138

const SIOCGPGRP = 35076

const SIOCGRARP = 35169

const SIOCGSTAMP = 35078

const SIOCGSTAMPNS = 35079

const SIOCPROTOPRIVATE = 35296

const SIOCRTMSG = 35085

const SIOCSARP = 35157

const SIOCSIFADDR = 35094

const SIOCSIFBR = 35137

const SIOCSIFBRDADDR = 35098

const SIOCSIFDSTADDR = 35096

const SIOCSIFENCAP = 35110

const SIOCSIFFLAGS = 35092

const SIOCSIFHWADDR = 35108

const SIOCSIFHWBROADCAST = 35127

const SIOCSIFLINK = 35089

const SIOCSIFMAP = 35185

const SIOCSIFMEM = 35104

const SIOCSIFMETRIC = 35102

const SIOCSIFMTU = 35106

const SIOCSIFNAME = 35107

const SIOCSIFNETMASK = 35100

const SIOCSIFPFLAGS = 35124

const SIOCSIFSLAVE = 35120

const SIOCSIFTXQLEN = 35139

const SIOCSPGRP = 35074

const SIOCSRARP = 35170

const SIOGIFINDEX = 35123

const SLOT_2_0 = 2080895

const SLOT_4_2_0 = 4028612735

const SORTER_MAX_MERGE_COUNT = 16

const SORTER_TYPE_INTEGER = 1

const SORTER_TYPE_TEXT = 2

const SORTFLAG_UseSorter = 1

const SPILLFLAG_NOSYNC = 4

const SPILLFLAG_OFF = 1

const SPILLFLAG_ROLLBACK = 2

const SPLICE_F_GIFT = 8

const SPLICE_F_MORE = 4

const SPLICE_F_MOVE = 1

const SPLICE_F_NONBLOCK = 2

const SQLITE3_TEXT = 3

const SQLITE_ABORT = 4

const SQLITE_ABORT_ROLLBACK = 516

const SQLITE_ACCESS_EXISTS = 0

const SQLITE_ACCESS_READ = 2

const SQLITE_ACCESS_READWRITE = 1

const SQLITE_AFF_BLOB = 65

const SQLITE_AFF_FLEXNUM = 70

const SQLITE_AFF_INTEGER = 68

const SQLITE_AFF_MASK = 71

const SQLITE_AFF_NONE = 64

const SQLITE_AFF_NUMERIC = 67

const SQLITE_AFF_REAL = 69

const SQLITE_AFF_TEXT = 66

const SQLITE_ALLOW_COVERING_INDEX_SCAN = 1

const SQLITE_ALTER_TABLE = 26

const SQLITE_AMALGAMATION = 1

const SQLITE_ANALYZE = 28

const SQLITE_ANY = 5

const SQLITE_ASCII = 1

const SQLITE_ATOMIC_INTRINSICS = 1

const SQLITE_ATTACH = 24

const SQLITE_AUTH = 23

const SQLITE_AUTH_USER = 279

const SQLITE_AllOpts = 4294967295

const SQLITE_AutoIndex = 32768

const SQLITE_BIGENDIAN = 0

const SQLITE_BIG_DBL = 1e+99

const SQLITE_BLDF1_INDEXED = 1

const SQLITE_BLDF1_UNIQUE = 2

const SQLITE_BLDF2_2NDPASS = 4

const SQLITE_BLOB = 4

const SQLITE_BUSY = 5

const SQLITE_BUSY_RECOVERY = 261

const SQLITE_BUSY_SNAPSHOT = 517

const SQLITE_BUSY_TIMEOUT = 773

const SQLITE_BYTEORDER = 1234

const SQLITE_BalancedMerge = 2097152

const SQLITE_BloomFilter = 524288

const SQLITE_BloomPulldown = 1048576

const SQLITE_CANTOPEN = 14

const SQLITE_CANTOPEN_BKPT = 0

const SQLITE_CANTOPEN_CONVPATH = 1038

const SQLITE_CANTOPEN_DIRTYWAL = 1294

const SQLITE_CANTOPEN_FULLPATH = 782

const SQLITE_CANTOPEN_ISDIR = 526

const SQLITE_CANTOPEN_NOTEMPDIR = 270

const SQLITE_CANTOPEN_SYMLINK = 1550

const SQLITE_CHANGESETAPPLY_FKNOACTION = 8

const SQLITE_CHANGESETAPPLY_IGNORENOOP = 4

const SQLITE_CHANGESETAPPLY_INVERT = 2

const SQLITE_CHANGESETAPPLY_NOSAVEPOINT = 1

const SQLITE_CHANGESETSTART_INVERT = 2

const SQLITE_CHANGESET_ABORT = 2

const SQLITE_CHANGESET_CONFLICT = 3

const SQLITE_CHANGESET_CONSTRAINT = 4

const SQLITE_CHANGESET_DATA = 1

const SQLITE_CHANGESET_FOREIGN_KEY = 5

const SQLITE_CHANGESET_NOTFOUND = 2

const SQLITE_CHANGESET_OMIT = 0

const SQLITE_CHANGESET_REPLACE = 1

const SQLITE_CHECKPOINT_FULL = 1

const SQLITE_CHECKPOINT_PASSIVE = 0

const SQLITE_CHECKPOINT_RESTART = 2

const SQLITE_CHECKPOINT_TRUNCATE = 3

const SQLITE_CONFIG_COVERING_INDEX_SCAN = 20

const SQLITE_CONFIG_GETMALLOC = 5

const SQLITE_CONFIG_GETMUTEX = 11

const SQLITE_CONFIG_GETPCACHE = 15

const SQLITE_CONFIG_GETPCACHE2 = 19

const SQLITE_CONFIG_HEAP = 8

const SQLITE_CONFIG_LOG = 16

const SQLITE_CONFIG_LOOKASIDE = 13

const SQLITE_CONFIG_MALLOC = 4

const SQLITE_CONFIG_MEMDB_MAXSIZE = 29

const SQLITE_CONFIG_MEMSTATUS = 9

const SQLITE_CONFIG_MMAP_SIZE = 22

const SQLITE_CONFIG_MULTITHREAD = 2

const SQLITE_CONFIG_MUTEX = 10

const SQLITE_CONFIG_PAGECACHE = 7

const SQLITE_CONFIG_PCACHE = 14

const SQLITE_CONFIG_PCACHE2 = 18

const SQLITE_CONFIG_PCACHE_HDRSZ = 24

const SQLITE_CONFIG_PMASZ = 25

const SQLITE_CONFIG_ROWID_IN_VIEW = 30

const SQLITE_CONFIG_SCRATCH = 6

const SQLITE_CONFIG_SERIALIZED = 3

const SQLITE_CONFIG_SINGLETHREAD = 1

const SQLITE_CONFIG_SMALL_MALLOC = 27

const SQLITE_CONFIG_SORTERREF_SIZE = 28

const SQLITE_CONFIG_SQLLOG = 21

const SQLITE_CONFIG_STMTJRNL_SPILL = 26

const SQLITE_CONFIG_URI = 17

const SQLITE_CONFIG_WIN32_HEAPSIZE = 23

const SQLITE_CONSTRAINT = 19

const SQLITE_CONSTRAINT_CHECK = 275

const SQLITE_CONSTRAINT_COMMITHOOK = 531

const SQLITE_CONSTRAINT_DATATYPE = 3091

const SQLITE_CONSTRAINT_FOREIGNKEY = 787

const SQLITE_CONSTRAINT_FUNCTION = 1043

const SQLITE_CONSTRAINT_NOTNULL = 1299

const SQLITE_CONSTRAINT_PINNED = 2835

const SQLITE_CONSTRAINT_PRIMARYKEY = 1555

const SQLITE_CONSTRAINT_ROWID = 2579

const SQLITE_CONSTRAINT_TRIGGER = 1811

const SQLITE_CONSTRAINT_UNIQUE = 2067

const SQLITE_CONSTRAINT_VTAB = 2323

const SQLITE_COPY = 0

const SQLITE_CORE = 1

const SQLITE_CORRUPT = 11

const SQLITE_CORRUPT_BKPT = 0

const SQLITE_CORRUPT_INDEX = 779

const SQLITE_CORRUPT_SEQUENCE = 523

const SQLITE_CORRUPT_VTAB = 267

const SQLITE_CREATE_INDEX = 1

const SQLITE_CREATE_TABLE = 2

const SQLITE_CREATE_TEMP_INDEX = 3

const SQLITE_CREATE_TEMP_TABLE = 4

const SQLITE_CREATE_TEMP_TRIGGER = 5

const SQLITE_CREATE_TEMP_VIEW = 6

const SQLITE_CREATE_TRIGGER = 7

const SQLITE_CREATE_VIEW = 8

const SQLITE_CREATE_VTABLE = 29

const SQLITE_CacheSpill = 32

const SQLITE_CellSizeCk = 2097152

const SQLITE_CkptFullFSync = 16

const SQLITE_Coroutines = 33554432

const SQLITE_CountOfView = 512

const SQLITE_CoverIdxScan = 32

const SQLITE_CursorHints = 1024

const SQLITE_DBCONFIG_DEFENSIVE = 1010

const SQLITE_DBCONFIG_DQS_DDL = 1014

const SQLITE_DBCONFIG_DQS_DML = 1013

const SQLITE_DBCONFIG_ENABLE_FKEY = 1002

const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = 1004

const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = 1005

const SQLITE_DBCONFIG_ENABLE_QPSG = 1007

const SQLITE_DBCONFIG_ENABLE_TRIGGER = 1003

const SQLITE_DBCONFIG_ENABLE_VIEW = 1015

const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE = 1012

const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT = 1016

const SQLITE_DBCONFIG_LOOKASIDE = 1001

const SQLITE_DBCONFIG_MAINDBNAME = 1000

const SQLITE_DBCONFIG_MAX = 1019

const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = 1006

const SQLITE_DBCONFIG_RESET_DATABASE = 1009

const SQLITE_DBCONFIG_REVERSE_SCANORDER = 1019

const SQLITE_DBCONFIG_STMT_SCANSTATUS = 1018

const SQLITE_DBCONFIG_TRIGGER_EQP = 1008

const SQLITE_DBCONFIG_TRUSTED_SCHEMA = 1017

const SQLITE_DBCONFIG_WRITABLE_SCHEMA = 1011

const SQLITE_DBSTATUS_CACHE_HIT = 7

const SQLITE_DBSTATUS_CACHE_MISS = 8

const SQLITE_DBSTATUS_CACHE_SPILL = 12

const SQLITE_DBSTATUS_CACHE_USED = 1

const SQLITE_DBSTATUS_CACHE_USED_SHARED = 11

const SQLITE_DBSTATUS_CACHE_WRITE = 9

const SQLITE_DBSTATUS_DEFERRED_FKS = 10

const SQLITE_DBSTATUS_LOOKASIDE_HIT = 4

const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL = 6

const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE = 5

const SQLITE_DBSTATUS_LOOKASIDE_USED = 0

const SQLITE_DBSTATUS_MAX = 12

const SQLITE_DBSTATUS_SCHEMA_USED = 2

const SQLITE_DBSTATUS_STMT_USED = 3

const SQLITE_DEFAULT_AUTOVACUUM = 0

const SQLITE_DEFAULT_CACHE_SIZE = -2000

const SQLITE_DEFAULT_FILE_FORMAT = 4

const SQLITE_DEFAULT_FILE_PERMISSIONS = 420

const SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT = -1

const SQLITE_DEFAULT_LOOKASIDE = 40

const SQLITE_DEFAULT_MEMSTATUS = 0

const SQLITE_DEFAULT_MMAP_SIZE = 0

const SQLITE_DEFAULT_OPTIMIZE_LIMIT = 2000

const SQLITE_DEFAULT_PAGE_SIZE = 4096

const SQLITE_DEFAULT_PCACHE_INITSZ = 20

const SQLITE_DEFAULT_PROXYDIR_PERMISSIONS = 493

const SQLITE_DEFAULT_RECURSIVE_TRIGGERS = 0

const SQLITE_DEFAULT_SECTOR_SIZE = 4096

const SQLITE_DEFAULT_SORTERREF_SIZE = 2147483647

const SQLITE_DEFAULT_SYNCHRONOUS = 2

const SQLITE_DEFAULT_WAL_AUTOCHECKPOINT = 1000

const SQLITE_DEFAULT_WAL_SYNCHRONOUS = 2

const SQLITE_DEFAULT_WORKER_THREADS = 0

const SQLITE_DELETE = 9

const SQLITE_DENY = 1

const SQLITE_DESERIALIZE_FREEONCLOSE = 1

const SQLITE_DESERIALIZE_READONLY = 4

const SQLITE_DESERIALIZE_RESIZEABLE = 2

const SQLITE_DETACH = 25

const SQLITE_DETERMINISTIC = 2048

const SQLITE_DIGIT_SEPARATOR = 95

const SQLITE_DIRECTONLY = 524288

const SQLITE_DIRECT_OVERFLOW_READ = 1

const SQLITE_DONE = 101

const SQLITE_DQS = 3

const SQLITE_DROP_INDEX = 10

const SQLITE_DROP_TABLE = 11

const SQLITE_DROP_TEMP_INDEX = 12

const SQLITE_DROP_TEMP_TABLE = 13

const SQLITE_DROP_TEMP_TRIGGER = 14

const SQLITE_DROP_TEMP_VIEW = 15

const SQLITE_DROP_TRIGGER = 16

const SQLITE_DROP_VIEW = 17

const SQLITE_DROP_VTABLE = 30

const SQLITE_Defensive = 268435456

const SQLITE_DeferFKs = 524288

const SQLITE_DistinctOpt = 16

const SQLITE_DqsDDL = 536870912

const SQLITE_DqsDML = 1073741824

const SQLITE_ECEL_DUP = 1

const SQLITE_ECEL_FACTOR = 2

const SQLITE_ECEL_OMITREF = 8

const SQLITE_ECEL_REF = 4

const SQLITE_EMPTY = 16

const SQLITE_ENABLE_COLUMN_METADATA = 1

const SQLITE_ENABLE_DBSTAT_VTAB = 1

const SQLITE_ENABLE_FTS5 = 1

const SQLITE_ENABLE_GEOPOLY = 1

const SQLITE_ENABLE_JSON1 = 1

const SQLITE_ENABLE_LOCKING_STYLE = 0

const SQLITE_ENABLE_MATH_FUNCTIONS = 1

const SQLITE_ENABLE_MEMORY_MANAGEMENT = 1

const SQLITE_ENABLE_OFFSET_SQL_FUNC = 1

const SQLITE_ENABLE_PREUPDATE_HOOK = 1

const SQLITE_ENABLE_RBU = 1

const SQLITE_ENABLE_RTREE = 1

const SQLITE_ENABLE_SESSION = 1

const SQLITE_ENABLE_SNAPSHOT = 1

const SQLITE_ENABLE_STAT4 = 1

const SQLITE_ENABLE_UNLOCK_NOTIFY = 1

const SQLITE_ERROR = 1

const SQLITE_ERROR_MISSING_COLLSEQ = 257

const SQLITE_ERROR_RETRY = 513

const SQLITE_ERROR_SNAPSHOT = 769

const SQLITE_EXTERN = 0

const SQLITE_EnableQPSG = 8388608

const SQLITE_EnableTrigger = 262144

const SQLITE_EnableView = 2147483648

const SQLITE_FAIL = 3

const SQLITE_FAULTINJECTOR_COUNT = 1

const SQLITE_FAULTINJECTOR_MALLOC = 0

const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = 31

const SQLITE_FCNTL_BUSYHANDLER = 15

const SQLITE_FCNTL_CHUNK_SIZE = 6

const SQLITE_FCNTL_CKPT_DONE = 37

const SQLITE_FCNTL_CKPT_START = 39

const SQLITE_FCNTL_CKSM_FILE = 41

const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = 32

const SQLITE_FCNTL_COMMIT_PHASETWO = 22

const SQLITE_FCNTL_DATA_VERSION = 35

const SQLITE_FCNTL_DB_UNCHANGED = 3389603744

const SQLITE_FCNTL_EXTERNAL_READER = 40

const SQLITE_FCNTL_FILE_POINTER = 7

const SQLITE_FCNTL_GET_LOCKPROXYFILE = 2

const SQLITE_FCNTL_HAS_MOVED = 20

const SQLITE_FCNTL_JOURNAL_POINTER = 28

const SQLITE_FCNTL_LAST_ERRNO = 4

const SQLITE_FCNTL_LOCKSTATE = 1

const SQLITE_FCNTL_LOCK_TIMEOUT = 34

const SQLITE_FCNTL_MMAP_SIZE = 18

const SQLITE_FCNTL_OVERWRITE = 11

const SQLITE_FCNTL_PDB = 30

const SQLITE_FCNTL_PERSIST_WAL = 10

const SQLITE_FCNTL_POWERSAFE_OVERWRITE = 13

const SQLITE_FCNTL_PRAGMA = 14

const SQLITE_FCNTL_RBU = 26

const SQLITE_FCNTL_RBUCNT = 5149216

const SQLITE_FCNTL_RESERVE_BYTES = 38

const SQLITE_FCNTL_RESET_CACHE = 42

const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = 33

const SQLITE_FCNTL_SET_LOCKPROXYFILE = 3

const SQLITE_FCNTL_SIZE_HINT = 5

const SQLITE_FCNTL_SIZE_LIMIT = 36

const SQLITE_FCNTL_SYNC = 21

const SQLITE_FCNTL_SYNC_OMITTED = 8

const SQLITE_FCNTL_TEMPFILENAME = 16

const SQLITE_FCNTL_TRACE = 19

const SQLITE_FCNTL_VFSNAME = 12

const SQLITE_FCNTL_VFS_POINTER = 27

const SQLITE_FCNTL_WAL_BLOCK = 24

const SQLITE_FCNTL_WIN32_AV_RETRY = 9

const SQLITE_FCNTL_WIN32_GET_HANDLE = 29

const SQLITE_FCNTL_WIN32_SET_HANDLE = 23

const SQLITE_FCNTL_ZIPVFS = 25

const SQLITE_FILE_HEADER = "SQLite format 3"

const SQLITE_FLOAT = 2

const SQLITE_FORMAT = 24

const SQLITE_FP_PRECISION_LIMIT = 100000000

const SQLITE_FRAME_MAGIC = 2275391262

const SQLITE_FSFLAGS_IS_MSDOS = 1

const SQLITE_FTS5_MAX_EXPR_DEPTH = 256

const SQLITE_FULL = 13

const SQLITE_FUNCTION = 31

const SQLITE_FUNC_ANYORDER = 134217728

const SQLITE_FUNC_BUILTIN = 8388608

const SQLITE_FUNC_BYTELEN = 192

const SQLITE_FUNC_CASE = 8

const SQLITE_FUNC_CONSTANT = 2048

const SQLITE_FUNC_COUNT = 256

const SQLITE_FUNC_DIRECT = 524288

const SQLITE_FUNC_ENCMASK = 3

const SQLITE_FUNC_EPHEM = 16

const SQLITE_FUNC_HASH_SZ = 23

const SQLITE_FUNC_INLINE = 4194304

const SQLITE_FUNC_INTERNAL = 262144

const SQLITE_FUNC_LENGTH = 64

const SQLITE_FUNC_LIKE = 4

const SQLITE_FUNC_MINMAX = 4096

const SQLITE_FUNC_NEEDCOLL = 32

const SQLITE_FUNC_RUNONLY = 32768

const SQLITE_FUNC_SLOCHNG = 8192

const SQLITE_FUNC_TEST = 16384

const SQLITE_FUNC_TYPEOF = 128

const SQLITE_FUNC_UNLIKELY = 1024

const SQLITE_FUNC_UNSAFE = 2097152

const SQLITE_FUNC_WINDOW = 65536

const SQLITE_FactorOutConst = 8

const SQLITE_FlttnUnionAll = 8388608

const SQLITE_ForeignKeys = 16384

const SQLITE_Fts3Tokenizer = 4194304

const SQLITE_FullColNames = 4

const SQLITE_FullFSync = 8

const SQLITE_GET_LOCKPROXYFILE = 2

const SQLITE_GroupByOrder = 4

const SQLITE_HAVE_C99_MATH_FUNCS = 1

const SQLITE_HAVE_ZLIB = 1

const SQLITE_IDXTYPE_APPDEF = 0

const SQLITE_IDXTYPE_IPK = 3

const SQLITE_IDXTYPE_PRIMARYKEY = 2

const SQLITE_IDXTYPE_UNIQUE = 1

const SQLITE_IGNORE = 2

const SQLITE_INDEX_CONSTRAINT_EQ = 2

const SQLITE_INDEX_CONSTRAINT_FUNCTION = 150

const SQLITE_INDEX_CONSTRAINT_GE = 32

const SQLITE_INDEX_CONSTRAINT_GLOB = 66

const SQLITE_INDEX_CONSTRAINT_GT = 4

const SQLITE_INDEX_CONSTRAINT_IS = 72

const SQLITE_INDEX_CONSTRAINT_ISNOT = 69

const SQLITE_INDEX_CONSTRAINT_ISNOTNULL = 70

const SQLITE_INDEX_CONSTRAINT_ISNULL = 71

const SQLITE_INDEX_CONSTRAINT_LE = 8

const SQLITE_INDEX_CONSTRAINT_LIKE = 65

const SQLITE_INDEX_CONSTRAINT_LIMIT = 73

const SQLITE_INDEX_CONSTRAINT_LT = 16

const SQLITE_INDEX_CONSTRAINT_MATCH = 64

const SQLITE_INDEX_CONSTRAINT_NE = 68

const SQLITE_INDEX_CONSTRAINT_OFFSET = 74

const SQLITE_INDEX_CONSTRAINT_REGEXP = 67

const SQLITE_INDEX_SCAN_UNIQUE = 1

const SQLITE_INNOCUOUS = 2097152

const SQLITE_INSERT = 18

const SQLITE_INTEGER = 1

const SQLITE_INTEGRITY_CHECK_ERROR_MAX = 100

const SQLITE_INTERNAL = 2

const SQLITE_INTERRUPT = 9

const SQLITE_IOCAP_ATOMIC = 1

const SQLITE_IOCAP_ATOMIC16K = 64

const SQLITE_IOCAP_ATOMIC1K = 4

const SQLITE_IOCAP_ATOMIC2K = 8

const SQLITE_IOCAP_ATOMIC32K = 128

const SQLITE_IOCAP_ATOMIC4K = 16

const SQLITE_IOCAP_ATOMIC512 = 2

const SQLITE_IOCAP_ATOMIC64K = 256

const SQLITE_IOCAP_ATOMIC8K = 32

const SQLITE_IOCAP_BATCH_ATOMIC = 16384

const SQLITE_IOCAP_IMMUTABLE = 8192

const SQLITE_IOCAP_POWERSAFE_OVERWRITE = 4096

const SQLITE_IOCAP_SAFE_APPEND = 512

const SQLITE_IOCAP_SEQUENTIAL = 1024

const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = 2048

const SQLITE_IOERR = 10

const SQLITE_IOERR_ACCESS = 3338

const SQLITE_IOERR_AUTH = 7178

const SQLITE_IOERR_BEGIN_ATOMIC = 7434

const SQLITE_IOERR_BLOCKED = 2826

const SQLITE_IOERR_CHECKRESERVEDLOCK = 3594

const SQLITE_IOERR_CLOSE = 4106

const SQLITE_IOERR_COMMIT_ATOMIC = 7690

const SQLITE_IOERR_CONVPATH = 6666

const SQLITE_IOERR_CORRUPTFS = 8458

const SQLITE_IOERR_DATA = 8202

const SQLITE_IOERR_DELETE = 2570

const SQLITE_IOERR_DELETE_NOENT = 5898

const SQLITE_IOERR_DIR_CLOSE = 4362

const SQLITE_IOERR_DIR_FSYNC = 1290

const SQLITE_IOERR_FSTAT = 1802

const SQLITE_IOERR_FSYNC = 1034

const SQLITE_IOERR_GETTEMPPATH = 6410

const SQLITE_IOERR_IN_PAGE = 8714

const SQLITE_IOERR_LOCK = 3850

const SQLITE_IOERR_MMAP = 6154

const SQLITE_IOERR_NOMEM = 3082

const SQLITE_IOERR_NOMEM_BKPT = 3082

const SQLITE_IOERR_RDLOCK = 2314

const SQLITE_IOERR_READ = 266

const SQLITE_IOERR_ROLLBACK_ATOMIC = 7946

const SQLITE_IOERR_SEEK = 5642

const SQLITE_IOERR_SHMLOCK = 5130

const SQLITE_IOERR_SHMMAP = 5386

const SQLITE_IOERR_SHMOPEN = 4618

const SQLITE_IOERR_SHMSIZE = 4874

const SQLITE_IOERR_SHORT_READ = 522

const SQLITE_IOERR_TRUNCATE = 1546

const SQLITE_IOERR_UNLOCK = 2058

const SQLITE_IOERR_VNODE = 6922

const SQLITE_IOERR_WRITE = 778

const SQLITE_IgnoreChecks = 512

const SQLITE_IndexedExpr = 16777216

const SQLITE_JUMPIFNULL = 16

const SQLITE_LAST_ERRNO = 4

const SQLITE_LIKE_DOESNT_MATCH_BLOBS = 1

const SQLITE_LIMIT_ATTACHED = 7

const SQLITE_LIMIT_COLUMN = 2

const SQLITE_LIMIT_COMPOUND_SELECT = 4

const SQLITE_LIMIT_EXPR_DEPTH = 3

const SQLITE_LIMIT_FUNCTION_ARG = 6

const SQLITE_LIMIT_LENGTH = 0

const SQLITE_LIMIT_LIKE_PATTERN_LENGTH = 8

const SQLITE_LIMIT_SQL_LENGTH = 1

const SQLITE_LIMIT_TRIGGER_DEPTH = 10

const SQLITE_LIMIT_VARIABLE_NUMBER = 9

const SQLITE_LIMIT_VDBE_OP = 5

const SQLITE_LIMIT_WORKER_THREADS = 11

const SQLITE_LITTLEENDIAN = 1

const SQLITE_LOCKED = 6

const SQLITE_LOCKED_SHAREDCACHE = 262

const SQLITE_LOCKED_VTAB = 518

const SQLITE_LOCK_EXCLUSIVE = 4

const SQLITE_LOCK_NONE = 0

const SQLITE_LOCK_PENDING = 3

const SQLITE_LOCK_RESERVED = 2

const SQLITE_LOCK_SHARED = 1

const SQLITE_LegacyAlter = 67108864

const SQLITE_LegacyFileFmt = 2

const SQLITE_LoadExtFunc = 131072

const SQLITE_LoadExtension = 65536

const SQLITE_MALLOC_SOFT_LIMIT = 1024

const SQLITE_MATCH = 0

const SQLITE_MAX_ALLOCATION_SIZE = 2147483391

const SQLITE_MAX_ATTACHED = 10

const SQLITE_MAX_COLUMN = 2000

const SQLITE_MAX_COMPOUND_SELECT = 500

const SQLITE_MAX_DB = 12

const SQLITE_MAX_DEFAULT_PAGE_SIZE = 8192

const SQLITE_MAX_EXPR_DEPTH = 1000

const SQLITE_MAX_FILE_FORMAT = 4

const SQLITE_MAX_FUNCTION_ARG = 127

const SQLITE_MAX_LENGTH = 1000000000

const SQLITE_MAX_LIKE_PATTERN_LENGTH = 50000

const SQLITE_MAX_MEMORY = 0

const SQLITE_MAX_MMAP_SIZE = 2147418112

const SQLITE_MAX_PAGE_COUNT = 4294967294

const SQLITE_MAX_PAGE_SIZE = 65536

const SQLITE_MAX_PATHLEN = 4096

const SQLITE_MAX_PMASZ = 536870912

const SQLITE_MAX_PREPARE_RETRY = 25

const SQLITE_MAX_SCHEMA_RETRY = 50

const SQLITE_MAX_SQL_LENGTH = 1000000000

const SQLITE_MAX_SRCLIST = 200

const SQLITE_MAX_SYMLINK = 200

const SQLITE_MAX_SYMLINKS = 100

const SQLITE_MAX_TRIGGER_DEPTH = 1000

const SQLITE_MAX_VARIABLE_NUMBER = 32766

const SQLITE_MAX_VDBE_OP = 250000000

const SQLITE_MAX_WORKER_THREADS = 8

const SQLITE_MEMDB_DEFAULT_MAXSIZE = 1073741824

const SQLITE_MINIMUM_FILE_DESCRIPTOR = 3

const SQLITE_MISMATCH = 20

const SQLITE_MISUSE = 21

const SQLITE_MISUSE_BKPT = 0

const SQLITE_MUTEX_FAST = 0

const SQLITE_MUTEX_NREF = 0

const SQLITE_MUTEX_RECURSIVE = 1

const SQLITE_MUTEX_STATIC_APP1 = 8

const SQLITE_MUTEX_STATIC_APP2 = 9

const SQLITE_MUTEX_STATIC_APP3 = 10

const SQLITE_MUTEX_STATIC_LRU = 6

const SQLITE_MUTEX_STATIC_LRU2 = 7

const SQLITE_MUTEX_STATIC_MAIN = 2

const SQLITE_MUTEX_STATIC_MASTER = 2

const SQLITE_MUTEX_STATIC_MEM = 3

const SQLITE_MUTEX_STATIC_MEM2 = 4

const SQLITE_MUTEX_STATIC_OPEN = 4

const SQLITE_MUTEX_STATIC_PMEM = 7

const SQLITE_MUTEX_STATIC_PRNG = 5

const SQLITE_MUTEX_STATIC_TEMPDIR = 11

const SQLITE_MUTEX_STATIC_VFS1 = 11

const SQLITE_MUTEX_STATIC_VFS2 = 12

const SQLITE_MUTEX_STATIC_VFS3 = 13

const SQLITE_MX_JUMP_OPCODE = 64

const SQLITE_MinMaxOpt = 65536

const SQLITE_NOLFS = 22

const SQLITE_NOMATCH = 1

const SQLITE_NOMEM = 7

const SQLITE_NOMEM_BKPT = 7

const SQLITE_NOTADB = 26

const SQLITE_NOTFOUND = 12

const SQLITE_NOTICE = 27

const SQLITE_NOTICE_RBU = 795

const SQLITE_NOTICE_RECOVER_ROLLBACK = 539

const SQLITE_NOTICE_RECOVER_WAL = 283

const SQLITE_NOTNULL = 144

const SQLITE_NOWILDCARDMATCH = 2

const SQLITE_NTUNE = 6

const SQLITE_NULL = 5

const SQLITE_NULLEQ = 128

const SQLITE_N_BTREE_META = 16

const SQLITE_N_KEYWORD = 147

const SQLITE_N_LIMIT = 12

const SQLITE_N_STDTYPE = 6

const SQLITE_NoCkptOnClose = 2048

const SQLITE_NoSchemaError = 134217728

const SQLITE_NullCallback = 256

const SQLITE_NullUnusedCols = 67108864

const SQLITE_OK = 0

const SQLITE_OK_LOAD_PERMANENTLY = 256

const SQLITE_OK_SYMLINK = 512

const SQLITE_OPEN_AUTOPROXY = 32

const SQLITE_OPEN_CREATE = 4

const SQLITE_OPEN_DELETEONCLOSE = 8

const SQLITE_OPEN_EXCLUSIVE = 16

const SQLITE_OPEN_EXRESCODE = 33554432

const SQLITE_OPEN_FULLMUTEX = 65536

const SQLITE_OPEN_MAIN_DB = 256

const SQLITE_OPEN_MAIN_JOURNAL = 2048

const SQLITE_OPEN_MASTER_JOURNAL = 16384

const SQLITE_OPEN_MEMORY = 128

const SQLITE_OPEN_NOFOLLOW = 16777216

const SQLITE_OPEN_NOMUTEX = 32768

const SQLITE_OPEN_PRIVATECACHE = 262144

const SQLITE_OPEN_READONLY = 1

const SQLITE_OPEN_READWRITE = 2

const SQLITE_OPEN_SHAREDCACHE = 131072

const SQLITE_OPEN_SUBJOURNAL = 8192

const SQLITE_OPEN_SUPER_JOURNAL = 16384

const SQLITE_OPEN_TEMP_DB = 512

const SQLITE_OPEN_TEMP_JOURNAL = 4096

const SQLITE_OPEN_TRANSIENT_DB = 1024

const SQLITE_OPEN_URI = 64

const SQLITE_OPEN_WAL = 524288

const SQLITE_OS_UNIX = 1

const SQLITE_OmitNoopJoin = 256

const SQLITE_OmitOrderBy = 262144

const SQLITE_OnePass = 134217728

const SQLITE_OrderByIdxJoin = 64

const SQLITE_PERM = 3

const SQLITE_POWERSAFE_OVERWRITE = 1

const SQLITE_PRAGMA = 19

const SQLITE_PREPARE_MASK = 15

const SQLITE_PREPARE_NORMALIZE = 2

const SQLITE_PREPARE_NO_VTAB = 4

const SQLITE_PREPARE_PERSISTENT = 1

const SQLITE_PREPARE_SAVESQL = 128

const SQLITE_PRINTF_INTERNAL = 1

const SQLITE_PRINTF_MALLOCED = 4

const SQLITE_PRINTF_SQLFUNC = 2

const SQLITE_PRINT_BUF_SIZE = 70

const SQLITE_PRIVATE = 0

const SQLITE_PROTOCOL = 15

const SQLITE_PTRSIZE = 8

const SQLITE_PropagateConst = 32768

const SQLITE_PushDown = 4096

const SQLITE_QUERY_PLANNER_LIMIT = 20000

const SQLITE_QUERY_PLANNER_LIMIT_INCR = 1000

const SQLITE_QueryFlattener = 1

const SQLITE_QueryOnly = 1048576

const SQLITE_RANGE = 25

const SQLITE_RBU_STATE_CHECKPOINT = 3

const SQLITE_RBU_STATE_DONE = 4

const SQLITE_RBU_STATE_ERROR = 5

const SQLITE_RBU_STATE_MOVE = 2

const SQLITE_RBU_STATE_OAL = 1

const SQLITE_RBU_UPDATE_CACHESIZE = 16

const SQLITE_READ = 20

const SQLITE_READONLY = 8

const SQLITE_READONLY_CANTINIT = 1288

const SQLITE_READONLY_CANTLOCK = 520

const SQLITE_READONLY_DBMOVED = 1032

const SQLITE_READONLY_DIRECTORY = 1544

const SQLITE_READONLY_RECOVERY = 264

const SQLITE_READONLY_ROLLBACK = 776

const SQLITE_RECURSIVE = 33

const SQLITE_REINDEX = 27

const SQLITE_REPLACE = 5

const SQLITE_RESULT_SUBTYPE = 16777216

const SQLITE_ROLLBACK = 1

const SQLITE_ROW = 100

const SQLITE_RecTriggers = 8192

const SQLITE_ReleaseReg = 4194304

const SQLITE_ResetDatabase = 33554432

const SQLITE_ReverseOrder = 4096

const SQLITE_SAVEPOINT = 32

const SQLITE_SCANSTAT_COMPLEX = 1

const SQLITE_SCANSTAT_EST = 2

const SQLITE_SCANSTAT_EXPLAIN = 4

const SQLITE_SCANSTAT_NAME = 3

const SQLITE_SCANSTAT_NCYCLE = 7

const SQLITE_SCANSTAT_NLOOP = 0

const SQLITE_SCANSTAT_NVISIT = 1

const SQLITE_SCANSTAT_PARENTID = 6

const SQLITE_SCANSTAT_SELECTID = 5

const SQLITE_SCHEMA = 17

const SQLITE_SELECT = 21

const SQLITE_SERIALIZE_NOCOPY = 1

const SQLITE_SESSION_CONFIG_STRMSIZE = 1

const SQLITE_SESSION_OBJCONFIG_ROWID = 2

const SQLITE_SESSION_OBJCONFIG_SIZE = 1

const SQLITE_SET_LOCKPROXYFILE = 3

const SQLITE_SHM_EXCLUSIVE = 8

const SQLITE_SHM_LOCK = 2

const SQLITE_SHM_NLOCK = 8

const SQLITE_SHM_SHARED = 4

const SQLITE_SHM_UNLOCK = 1

const SQLITE_SORTER_PMASZ = 250

const SQLITE_SOUNDEX = 1

const SQLITE_SOURCE_ID = "2024-05-23 13:25:27 96c92aba00c8375bc32fafcdf12429c58bd8aabfcadab6683e35bbb9cdebf19e"

const SQLITE_SO_ASC = 0

const SQLITE_SO_DESC = 1

const SQLITE_SO_UNDEFINED = -1

const SQLITE_STAT4_SAMPLES = 24

const SQLITE_STATE_BUSY = 109

const SQLITE_STATE_CLOSED = 206

const SQLITE_STATE_ERROR = 213

const SQLITE_STATE_OPEN = 118

const SQLITE_STATE_SICK = 186

const SQLITE_STATE_ZOMBIE = 167

const SQLITE_STATUS_MALLOC_COUNT = 9

const SQLITE_STATUS_MALLOC_SIZE = 5

const SQLITE_STATUS_MEMORY_USED = 0

const SQLITE_STATUS_PAGECACHE_OVERFLOW = 2

const SQLITE_STATUS_PAGECACHE_SIZE = 7

const SQLITE_STATUS_PAGECACHE_USED = 1

const SQLITE_STATUS_PARSER_STACK = 6

const SQLITE_STATUS_SCRATCH_OVERFLOW = 4

const SQLITE_STATUS_SCRATCH_SIZE = 8

const SQLITE_STATUS_SCRATCH_USED = 3

const SQLITE_STDCALL = 0

const SQLITE_STMTJRNL_SPILL = 65536

const SQLITE_STMTSTATUS_AUTOINDEX = 3

const SQLITE_STMTSTATUS_FILTER_HIT = 8

const SQLITE_STMTSTATUS_FILTER_MISS = 7

const SQLITE_STMTSTATUS_FULLSCAN_STEP = 1

const SQLITE_STMTSTATUS_MEMUSED = 99

const SQLITE_STMTSTATUS_REPREPARE = 5

const SQLITE_STMTSTATUS_RUN = 6

const SQLITE_STMTSTATUS_SORT = 2

const SQLITE_STMTSTATUS_VM_STEP = 4

const SQLITE_SUBTYPE = 1048576

const SQLITE_SYNC_DATAONLY = 16

const SQLITE_SYNC_FULL = 3

const SQLITE_SYNC_NORMAL = 2

const SQLITE_SYSTEM_MALLOC = 1

const SQLITE_SeekScan = 131072

const SQLITE_ShortColNames = 64

const SQLITE_SimplifyJoin = 8192

const SQLITE_SkipScan = 16384

const SQLITE_Stat4 = 2048

const SQLITE_StmtScanStatus = 1024

const SQLITE_TEMP_FILE_PREFIX = "etilqs_"

const SQLITE_TEMP_STORE = 1

const SQLITE_TESTCTRL_ALWAYS = 13

const SQLITE_TESTCTRL_ASSERT = 12

const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS = 10

const SQLITE_TESTCTRL_BITVEC_TEST = 8

const SQLITE_TESTCTRL_BYTEORDER = 22

const SQLITE_TESTCTRL_EXPLAIN_STMT = 19

const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS = 29

const SQLITE_TESTCTRL_FAULT_INSTALL = 9

const SQLITE_TESTCTRL_FIRST = 5

const SQLITE_TESTCTRL_FK_NO_ACTION = 7

const SQLITE_TESTCTRL_IMPOSTER = 25

const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS = 17

const SQLITE_TESTCTRL_ISINIT = 23

const SQLITE_TESTCTRL_ISKEYWORD = 16

const SQLITE_TESTCTRL_JSON_SELFCHECK = 14

const SQLITE_TESTCTRL_LAST = 34

const SQLITE_TESTCTRL_LOCALTIME_FAULT = 18

const SQLITE_TESTCTRL_LOGEST = 33

const SQLITE_TESTCTRL_NEVER_CORRUPT = 20

const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD = 19

const SQLITE_TESTCTRL_OPTIMIZATIONS = 15

const SQLITE_TESTCTRL_PARSER_COVERAGE = 26

const SQLITE_TESTCTRL_PENDING_BYTE = 11

const SQLITE_TESTCTRL_PRNG_RESET = 7

const SQLITE_TESTCTRL_PRNG_RESTORE = 6

const SQLITE_TESTCTRL_PRNG_SAVE = 5

const SQLITE_TESTCTRL_PRNG_SEED = 28

const SQLITE_TESTCTRL_RESERVE = 14

const SQLITE_TESTCTRL_RESULT_INTREAL = 27

const SQLITE_TESTCTRL_SCRATCHMALLOC = 17

const SQLITE_TESTCTRL_SEEK_COUNT = 30

const SQLITE_TESTCTRL_SORTER_MMAP = 24

const SQLITE_TESTCTRL_TRACEFLAGS = 31

const SQLITE_TESTCTRL_TUNE = 32

const SQLITE_TESTCTRL_USELONGDOUBLE = 34

const SQLITE_TESTCTRL_VDBE_COVERAGE = 21

const SQLITE_TEXT = 3

const SQLITE_THREADSAFE = 1

const SQLITE_THREADS_IMPLEMENTED = 1

const SQLITE_TOKEN_KEYWORD = 2

const SQLITE_TOKEN_QUOTED = 1

const SQLITE_TOOBIG = 18

const SQLITE_TRACE_CLOSE = 8

const SQLITE_TRACE_LEGACY = 64

const SQLITE_TRACE_NONLEGACY_MASK = 15

const SQLITE_TRACE_PROFILE = 2

const SQLITE_TRACE_ROW = 4

const SQLITE_TRACE_STMT = 1

const SQLITE_TRACE_XPROFILE = 128

const SQLITE_TRANSACTION = 22

const SQLITE_TXN_NONE = 0

const SQLITE_TXN_READ = 1

const SQLITE_TXN_WRITE = 2

const SQLITE_Transitive = 128

const SQLITE_TriggerEQP = 16777216

const SQLITE_TrustedSchema = 128

const SQLITE_UPDATE = 23

const SQLITE_USE_URI = 0

const SQLITE_UTF16 = 4

const SQLITE_UTF16BE = 3

const SQLITE_UTF16LE = 2

const SQLITE_UTF16NATIVE = 2

const SQLITE_UTF16_ALIGNED = 8

const SQLITE_UTF8 = 1

const SQLITE_VERSION = "3.46.0"

const SQLITE_VERSION_NUMBER = 3046000

const SQLITE_VTABRISK_High = 2

const SQLITE_VTABRISK_Low = 0

const SQLITE_VTABRISK_Normal = 1

const SQLITE_VTAB_CONSTRAINT_SUPPORT = 1

const SQLITE_VTAB_DIRECTONLY = 3

const SQLITE_VTAB_INNOCUOUS = 2

const SQLITE_VTAB_USES_ALL_SCHEMAS = 4

const SQLITE_WARNING = 28

const SQLITE_WARNING_AUTOINDEX = 284

const SQLITE_WIN32_DATA_DIRECTORY_TYPE = 1

const SQLITE_WIN32_TEMP_DIRECTORY_TYPE = 2

const SQLITE_WITHOUT_ZONEMALLOC = 1

const SQLITE_WindowFunc = 2

const SQLITE_WriteSchema = 1

const SRT_Coroutine = 13

const SRT_Discard = 4

const SRT_DistFifo = 5

const SRT_DistQueue = 6

const SRT_EphemTab = 12

const SRT_Except = 2

const SRT_Exists = 3

const SRT_Fifo = 8

const SRT_Mem = 10

const SRT_Output = 9

const SRT_Queue = 7

const SRT_Set = 11

const SRT_Table = 14

const SRT_Union = 1

const SRT_Upfrom = 15

const STATX_ALL = 4095

const STATX_ATIME = 32

const STATX_BASIC_STATS = 2047

const STATX_BLOCKS = 1024

const STATX_BTIME = 2048

const STATX_CTIME = 128

const STATX_GID = 16

const STATX_INO = 256

const STATX_MODE = 2

const STATX_MTIME = 64

const STATX_NLINK = 4

const STATX_SIZE = 512

const STATX_TYPE = 1

const STATX_UID = 8

const STAT_GET_NDLT = 4

const STAT_GET_NEQ = 2

const STAT_GET_NLT = 3

const STAT_GET_ROWID = 1

const STAT_GET_STAT1 = 0

const STDERR_FILENO = 2

const STDIN_FILENO = 0

const STDOUT_FILENO = 1

const SYNC_FILE_RANGE_WAIT_AFTER = 4

const SYNC_FILE_RANGE_WAIT_BEFORE = 1

const SYNC_FILE_RANGE_WRITE = 2

const S_IEXEC = 64

const S_IFBLK = 24576

const S_IFCHR = 8192

const S_IFDIR = 16384

const S_IFIFO = 4096

const S_IFLNK = 40960

const S_IFMT = 61440

const S_IFREG = 32768

const S_IFSOCK = 49152

const S_IREAD = 256

const S_IRGRP = 32

const S_IROTH = 4

const S_IRUSR = 256

const S_IRWXG = 56

const S_IRWXO = 7

const S_IRWXU = 448

const S_ISGID = 1024

const S_ISUID = 2048

const S_ISVTX = 512

const S_IWGRP = 16

const S_IWOTH = 2

const S_IWRITE = 128

const S_IWUSR = 128

const S_IXGRP = 8

const S_IXOTH = 1

const S_IXUSR = 64

const TABTYP_NORM = 0

const TABTYP_VIEW = 2

const TABTYP_VTAB = 1

const TCFLSH = 21515

const TCGETA = 21509

const TCGETS = 21505

const TCGETX = 21554

const TCSBRK = 21513

const TCSBRKP = 21541

const TCSETA = 21510

const TCSETAF = 21512

const TCSETAW = 21511

const TCSETS = 21506

const TCSETSF = 21508

const TCSETSW = 21507

const TCSETX = 21555

const TCSETXF = 21556

const TCSETXW = 21557

const TCXONC = 21514

const TERM_ANDINFO = 32

const TERM_CODED = 4

const TERM_COPIED = 8

const TERM_DYNAMIC = 1

const TERM_HEURTRUTH = 8192

const TERM_HIGHTRUTH = 16384

const TERM_IS = 2048

const TERM_LIKE = 1024

const TERM_LIKECOND = 512

const TERM_LIKEOPT = 256

const TERM_OK = 64

const TERM_ORINFO = 16

const TERM_SLICE = 32768

const TERM_VARSELECT = 4096

const TERM_VIRTUAL = 2

const TERM_VNULL = 128

const TF_Autoincrement = 8

const TF_Ephemeral = 16384

const TF_Eponymous = 32768

const TF_HasGenerated = 96

const TF_HasHidden = 2

const TF_HasNotNull = 2048

const TF_HasPrimaryKey = 4

const TF_HasStat1 = 16

const TF_HasStat4 = 8192

const TF_HasStored = 64

const TF_HasVirtual = 32

const TF_MaybeReanalyze = 256

const TF_NoVisibleRowid = 512

const TF_OOOHidden = 1024

const TF_Readonly = 1

const TF_Shadow = 4096

const TF_Strict = 65536

const TF_WithoutRowid = 128

const TIMER_ABSTIME = 1

const TIME_UTC = 1

const TIOCCBRK = 21544

const TIOCCONS = 21533

const TIOCEXCL = 21516

const TIOCGDEV = 2147767346

const TIOCGETD = 21540

const TIOCGEXCL = 2147767360

const TIOCGICOUNT = 21597

const TIOCGISO7816 = 2150126658

const TIOCGLCKTRMIOS = 21590

const TIOCGPGRP = 21519

const TIOCGPKT = 2147767352

const TIOCGPTLCK = 2147767353

const TIOCGPTN = 2147767344

const TIOCGPTPEER = 21569

const TIOCGRS485 = 21550

const TIOCGSERIAL = 21534

const TIOCGSID = 21545

const TIOCGSOFTCAR = 21529

const TIOCGWINSZ = 21523

const TIOCINQ = 21531

const TIOCLINUX = 21532

const TIOCMBIC = 21527

const TIOCMBIS = 21526

const TIOCMGET = 21525

const TIOCMIWAIT = 21596

const TIOCMSET = 21528

const TIOCM_CAR = 64

const TIOCM_CD = 64

const TIOCM_CTS = 32

const TIOCM_DSR = 256

const TIOCM_DTR = 2

const TIOCM_LE = 1

const TIOCM_LOOP = 32768

const TIOCM_OUT1 = 8192

const TIOCM_OUT2 = 16384

const TIOCM_RI = 128

const TIOCM_RNG = 128

const TIOCM_RTS = 4

const TIOCM_SR = 16

const TIOCM_ST = 8

const TIOCNOTTY = 21538

const TIOCNXCL = 21517

const TIOCOUTQ = 21521

const TIOCPKT = 21536

const TIOCPKT_DATA = 0

const TIOCPKT_DOSTOP = 32

const TIOCPKT_FLUSHREAD = 1

const TIOCPKT_FLUSHWRITE = 2

const TIOCPKT_IOCTL = 64

const TIOCPKT_NOSTOP = 16

const TIOCPKT_START = 8

const TIOCPKT_STOP = 4

const TIOCSBRK = 21543

const TIOCSCTTY = 21518

const TIOCSERCONFIG = 21587

const TIOCSERGETLSR = 21593

const TIOCSERGETMULTI = 21594

const TIOCSERGSTRUCT = 21592

const TIOCSERGWILD = 21588

const TIOCSERSETMULTI = 21595

const TIOCSERSWILD = 21589

const TIOCSER_TEMT = 1

const TIOCSETD = 21539

const TIOCSIG = 1074025526

const TIOCSISO7816 = 3223868483

const TIOCSLCKTRMIOS = 21591

const TIOCSPGRP = 21520

const TIOCSPTLCK = 1074025521

const TIOCSRS485 = 21551

const TIOCSSERIAL = 21535

const TIOCSSOFTCAR = 21530

const TIOCSTI = 21522

const TIOCSWINSZ = 21524

const TIOCVHANGUP = 21559

const TK_ABORT = 27

const TK_ACTION = 28

const TK_ADD = 163

const TK_AFTER = 29

const TK_AGG_COLUMN = 169

const TK_AGG_FUNCTION = 168

const TK_ALL = 135

const TK_ALTER = 162

const TK_ALWAYS = 96

const TK_ANALYZE = 30

const TK_AND = 44

const TK_ANY = 101

const TK_AS = 24

const TK_ASC = 31

const TK_ASTERISK = 180

const TK_ATTACH = 32

const TK_AUTOINCR = 126

const TK_BEFORE = 33

const TK_BEGIN = 5

const TK_BETWEEN = 48

const TK_BITAND = 102

const TK_BITNOT = 114

const TK_BITOR = 103

const TK_BLOB = 154

const TK_BY = 34

const TK_CASCADE = 35

const TK_CASE = 157

const TK_CAST = 36

const TK_CHECK = 124

const TK_COLLATE = 113

const TK_COLUMN = 167

const TK_COLUMNKW = 60

const TK_COMMA = 25

const TK_COMMIT = 10

const TK_CONCAT = 111

const TK_CONFLICT = 37

const TK_CONSTRAINT = 119

const TK_CREATE = 17

const TK_CTIME_KW = 100

const TK_CURRENT = 85

const TK_DATABASE = 38

const TK_DEFAULT = 120

const TK_DEFERRABLE = 131

const TK_DEFERRED = 7

const TK_DELETE = 128

const TK_DESC = 39

const TK_DETACH = 40

const TK_DISTINCT = 140

const TK_DO = 61

const TK_DOT = 141

const TK_DROP = 133

const TK_EACH = 41

const TK_ELSE = 160

const TK_END = 11

const TK_EQ = 53

const TK_ERROR = 182

const TK_ESCAPE = 58

const TK_EXCEPT = 136

const TK_EXCLUDE = 91

const TK_EXCLUSIVE = 9

const TK_EXISTS = 20

const TK_EXPLAIN = 2

const TK_FAIL = 42

const TK_FILTER = 166

const TK_FIRST = 83

const TK_FLOAT = 153

const TK_FOLLOWING = 86

const TK_FOR = 62

const TK_FOREIGN = 132

const TK_FROM = 142

const TK_FUNCTION = 172

const TK_GE = 57

const TK_GENERATED = 95

const TK_GROUP = 146

const TK_GROUPS = 92

const TK_GT = 54

const TK_HAVING = 147

const TK_ID = 59

const TK_IF = 18

const TK_IF_NULL_ROW = 179

const TK_IGNORE = 63

const TK_ILLEGAL = 185

const TK_IMMEDIATE = 8

const TK_IN = 49

const TK_INDEX = 161

const TK_INDEXED = 116

const TK_INITIALLY = 64

const TK_INSERT = 127

const TK_INSTEAD = 65

const TK_INTEGER = 155

const TK_INTERSECT = 137

const TK_INTO = 151

const TK_IS = 45

const TK_ISNOT = 171

const TK_ISNULL = 50

const TK_JOIN = 143

const TK_JOIN_KW = 118

const TK_KEY = 67

const TK_LAST = 84

const TK_LE = 55

const TK_LIKE_KW = 47

const TK_LIMIT = 148

const TK_LP = 22

const TK_LSHIFT = 104

const TK_LT = 56

const TK_MATCH = 46

const TK_MATERIALIZED = 97

const TK_MINUS = 107

const TK_NE = 52

const TK_NO = 66

const TK_NOT = 19

const TK_NOTHING = 152

const TK_NOTNULL = 51

const TK_NULL = 121

const TK_NULLS = 82

const TK_OF = 68

const TK_OFFSET = 69

const TK_ON = 115

const TK_OR = 43

const TK_ORDER = 145

const TK_OTHERS = 93

const TK_OVER = 165

const TK_PARTITION = 87

const TK_PLAN = 4

const TK_PLUS = 106

const TK_PRAGMA = 70

const TK_PRECEDING = 88

const TK_PRIMARY = 122

const TK_PTR = 112

const TK_QNUMBER = 183

const TK_QUERY = 3

const TK_RAISE = 71

const TK_RANGE = 89

const TK_RECURSIVE = 72

const TK_REFERENCES = 125

const TK_REGISTER = 176

const TK_REINDEX = 98

const TK_RELEASE = 14

const TK_REM = 110

const TK_RENAME = 99

const TK_REPLACE = 73

const TK_RESTRICT = 74

const TK_RETURNING = 150

const TK_ROLLBACK = 12

const TK_ROW = 75

const TK_ROWS = 76

const TK_RP = 23

const TK_RSHIFT = 105

const TK_SAVEPOINT = 13

const TK_SELECT = 138

const TK_SELECT_COLUMN = 178

const TK_SEMI = 1

const TK_SET = 130

const TK_SLASH = 109

const TK_SPACE = 184

const TK_SPAN = 181

const TK_STAR = 108

const TK_STRING = 117

const TK_TABLE = 16

const TK_TEMP = 21

const TK_THEN = 159

const TK_TIES = 94

const TK_TO = 15

const TK_TRANSACTION = 6

const TK_TRIGGER = 77

const TK_TRUEFALSE = 170

const TK_TRUTH = 175

const TK_UMINUS = 174

const TK_UNBOUNDED = 90

const TK_UNION = 134

const TK_UNIQUE = 123

const TK_UPDATE = 129

const TK_UPLUS = 173

const TK_USING = 144

const TK_VACUUM = 78

const TK_VALUES = 139

const TK_VARIABLE = 156

const TK_VECTOR = 177

const TK_VIEW = 79

const TK_VIRTUAL = 80

const TK_WHEN = 158

const TK_WHERE = 149

const TK_WINDOW = 164

const TK_WITH = 81

const TK_WITHOUT = 26

const TMP_MAX = 10000

const TOKEN = 0

const TRANS_NONE = 0

const TRANS_READ = 1

const TRANS_WRITE = 2

const TREETRACE_ENABLED = 0

const TRIGGER_AFTER = 2

const TRIGGER_BEFORE = 1

const UNIXFILE_DELETE = 32

const UNIXFILE_DIRSYNC = 8

const UNIXFILE_EXCL = 1

const UNIXFILE_NOLOCK = 128

const UNIXFILE_PERSIST_WAL = 4

const UNIXFILE_PSOW = 16

const UNIXFILE_RDONLY = 2

const UNIXFILE_URI = 64

const UNIX_SHM_BASE = 120

const UNIX_SHM_DMS = 128

const UNKNOWN_LOCK = 5

const USE_PREAD = 1

const UTIME_NOW = 1073741823

const UTIME_OMIT = 1073741822

const UpperToLower = 0

const VDBE_DISPLAY_P4 = 1

const VDBE_HALT_STATE = 3

const VDBE_INIT_STATE = 0

const VDBE_READY_STATE = 1

const VDBE_RUN_STATE = 2

const ViewCanHaveRowid = 0

const WALINDEX_HDR_SIZE = 0

const WALINDEX_MAX_VERSION = 3007000

const WALINDEX_PGSZ = 0

const WAL_ALL_BUT_WRITE = 1

const WAL_CKPT_LOCK = 1

const WAL_EXCLUSIVE_MODE = 1

const WAL_FRAME_HDRSIZE = 24

const WAL_HDRSIZE = 32

const WAL_HEAPMEMORY_MODE = 2

const WAL_LOCK_CKPT = 1

const WAL_LOCK_READ0 = 3

const WAL_LOCK_WRITE = 0

const WAL_MAGIC = 931071618

const WAL_MAX_VERSION = 3007000

const WAL_NORMAL_MODE = 0

const WAL_NREADER = 5

const WAL_RDONLY = 1

const WAL_RDWR = 0

const WAL_RECOVER_LOCK = 2

const WAL_RETRY = -1

const WAL_RETRY_BLOCKED_MASK = 0

const WAL_RETRY_PROTOCOL_LIMIT = 100

const WAL_SAVEPOINT_NDATA = 4

const WAL_SHM_RDONLY = 2

const WAL_WRITE_LOCK = 0

const WHERE_AGG_DISTINCT = 1024

const WHERE_AUTO_INDEX = 16384

const WHERE_BIGNULL_SORT = 524288

const WHERE_BLOOMFILTER = 4194304

const WHERE_BOTH_LIMIT = 48

const WHERE_BTM_LIMIT = 32

const WHERE_COLUMN_EQ = 1

const WHERE_COLUMN_IN = 4

const WHERE_COLUMN_NULL = 8

const WHERE_COLUMN_RANGE = 2

const WHERE_CONSTRAINT = 15

const WHERE_DISTINCTBY = 128

const WHERE_DISTINCT_NOOP = 0

const WHERE_DISTINCT_ORDERED = 2

const WHERE_DISTINCT_UNIQUE = 1

const WHERE_DISTINCT_UNORDERED = 3

const WHERE_DUPLICATES_OK = 16

const WHERE_EXPRIDX = 67108864

const WHERE_GROUPBY = 64

const WHERE_IDX_ONLY = 64

const WHERE_INDEXED = 512

const WHERE_IN_ABLE = 2048

const WHERE_IN_EARLYOUT = 262144

const WHERE_IN_SEEKSCAN = 1048576

const WHERE_IPK = 256

const WHERE_MULTI_OR = 8192

const WHERE_OMIT_OFFSET = 16777216

const WHERE_ONEPASS_DESIRED = 4

const WHERE_ONEPASS_MULTIROW = 8

const WHERE_ONEROW = 4096

const WHERE_ORDERBY_LIMIT = 2048

const WHERE_ORDERBY_MAX = 2

const WHERE_ORDERBY_MIN = 1

const WHERE_ORDERBY_NORMAL = 0

const WHERE_OR_SUBCLAUSE = 32

const WHERE_PARTIALIDX = 131072

const WHERE_RIGHT_JOIN = 4096

const WHERE_SELFCULL = 8388608

const WHERE_SKIPSCAN = 32768

const WHERE_SORTBYGROUP = 512

const WHERE_TOP_LIMIT = 16

const WHERE_TRANSCONS = 2097152

const WHERE_UNQ_WANTED = 65536

const WHERE_USE_LIMIT = 16384

const WHERE_VIRTUALTABLE = 1024

const WHERE_WANT_DISTINCT = 256

const WINDOW_AGGINVERSE = 2

const WINDOW_AGGSTEP = 3

const WINDOW_ENDING_INT = 1

const WINDOW_ENDING_NUM = 4

const WINDOW_NTH_VALUE_INT = 2

const WINDOW_RETURN_ROW = 1

const WINDOW_STARTING_INT = 0

const WINDOW_STARTING_NUM = 3

const WNOHANG = 1

const WO_ALL = 16383

const WO_AND = 1024

const WO_AUX = 64

const WO_EQ = 2

const WO_EQUIV = 2048

const WO_GE = 32

const WO_GT = 4

const WO_IN = 1

const WO_IS = 128

const WO_ISNULL = 256

const WO_LE = 8

const WO_LT = 16

const WO_NOOP = 4096

const WO_OR = 512

const WO_ROWVAL = 8192

const WO_SINGLE = 511

const WRC_Abort = 2

const WRC_Continue = 0

const WRC_Prune = 1

const WRITE_LOCK = 2

const WUNTRACED = 2

const W_OK = 2

const XN_EXPR = -2

const XN_ROWID = -1

const X_OK = 1

const YYDYNSTACK = 1

const YYFALLBACK = 1

const YYFREE = 0

const YYGROWABLESTACK = 1

const YYMALLOCARGTYPE = 0

const YYNOCODE = 322

const YYNOERRORRECOVERY = 1

const YYNRULE = 409

const YYNRULE_WITH_ACTION = 344

const YYNSTATE = 583

const YYNTOKEN = 186

const YYPARSEFREENEVERNULL = 1

const YYREALLOC = 0

const YYSTACKDEPTH = 100

const YYWILDCARD = 101

const YY_ACCEPT_ACTION = 1255

const YY_ACTTAB_COUNT = 2142

const YY_ERROR_ACTION = 1254

const YY_MAX_DSTRCTR = 319

const YY_MAX_REDUCE = 1665

const YY_MAX_SHIFT = 582

const YY_MAX_SHIFTREDUCE = 1253

const YY_MIN_DSTRCTR = 205

const YY_MIN_REDUCE = 1257

const YY_MIN_SHIFTREDUCE = 845

const YY_NO_ACTION = 1256

const YY_REDUCE_COUNT = 411

const YY_REDUCE_MAX = 1798

const YY_REDUCE_MIN = -275

const YY_SHIFT_COUNT = 582

const YY_SHIFT_MAX = 2128

const YY_SHIFT_MIN = 0

Variables

var (
	MutexCounters = libc.NewPerfCounter([]string{
		"enter-fast",
		"enter-recursive",
		"enter-recursive-loop",
		"try-fast",
		"try-recursive",
	})
	MutexEnterCallers = libc.NewStackCapture(4)
)

var Xsqlite3_data_directory uintptr

C documentation

/*
** If the following global variable points to a string which is the
** name of a directory, then that directory will be used to store
** all database files specified with a relative pathname.
**
** See also the "PRAGMA data_store_directory" SQL command.
*/

var Xsqlite3_temp_directory uintptr

C documentation

/*
** If the following global variable points to a string which is the
** name of a directory, then that directory will be used to store
** temporary files.
**
** See also the "PRAGMA temp_store_directory" SQL command.
*/

var Xsqlite3_version = [7]int8{'3', '.', '4', '6', '.', '0'}

C documentation

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
** but are associated with the library instead of the header file.  ^(Cautious
** programmers might include assert() statements in their application to
** verify that values returned by these interfaces match the macros in
** the header, and thus ensure that the application is
** compiled with matching library and header files.
**
** <blockquote><pre>
** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
** </pre></blockquote>)^
**
** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
** macro.  ^The sqlite3_libversion() function returns a pointer to the
** to the sqlite3_version[] string constant.  The sqlite3_libversion()
** function is provided for use in DLLs since DLL users usually do not have
** direct access to string constants within the DLL.  ^The
** sqlite3_libversion_number() function returns an integer equal to
** [SQLITE_VERSION_NUMBER].  ^(The sqlite3_sourceid() function returns
** a pointer to a string constant whose value is the same as the
** [SQLITE_SOURCE_ID] C preprocessor macro.  Except if SQLite is built
** using an edited copy of [the amalgamation], then the last four characters
** of the hash might be different from [SQLITE_SOURCE_ID].)^
**
** See also: [sqlite_version()] and [sqlite_source_id()].
*/

Functions

func PatchIssue199

func PatchIssue199()

https://gitlab.com/cznic/sqlite/-/issues/199

We are currently stuck on libc@v1.55.3. Until that is resolved - fix the problem at runtime.

func X__ccgo_sqlite3_log

func X__ccgo_sqlite3_log(t *libc.TLS, iErrCode int32, zFormat uintptr, va uintptr)

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

func Xsqlite3_aggregate_context

func Xsqlite3_aggregate_context(tls *libc.TLS, p uintptr, nByte int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, p uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, xInit uintptr) (r int32)

C documentation

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

func Xsqlite3_autovacuum_pages

func Xsqlite3_autovacuum_pages(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr, xDestructor uintptr) (r int32)

C documentation

/*
** Register a function to be invoked prior to each autovacuum that
** determines the number of pages to vacuum.
*/

func Xsqlite3_backup_finish

func Xsqlite3_backup_finish(tls *libc.TLS, p uintptr) (r int32)

C documentation

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

func Xsqlite3_backup_init

func Xsqlite3_backup_init(tls *libc.TLS, pDestDb uintptr, zDestDb uintptr, pSrcDb uintptr, zSrcDb uintptr) (r uintptr)

C documentation

/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
*/

func Xsqlite3_backup_pagecount

func Xsqlite3_backup_pagecount(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, p uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, p uintptr, nPage int32) (r int32)

C documentation

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

func Xsqlite3_bind_blob

func Xsqlite3_bind_blob(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData int32, xDel uintptr) (r int32)

C documentation

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

func Xsqlite3_bind_blob64

func Xsqlite3_bind_blob64(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData Tsqlite3_uint64, xDel uintptr) (r int32)

func Xsqlite3_bind_double

func Xsqlite3_bind_double(tls *libc.TLS, pStmt uintptr, i int32, rValue float64) (r int32)

func Xsqlite3_bind_int

func Xsqlite3_bind_int(tls *libc.TLS, p uintptr, i int32, iValue int32) (r int32)

func Xsqlite3_bind_int64

func Xsqlite3_bind_int64(tls *libc.TLS, pStmt uintptr, i int32, iValue Tsqlite_int64) (r int32)

func Xsqlite3_bind_null

func Xsqlite3_bind_null(tls *libc.TLS, pStmt uintptr, i int32) (r int32)

func Xsqlite3_bind_parameter_count

func Xsqlite3_bind_parameter_count(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr, zName uintptr) (r int32)

func Xsqlite3_bind_parameter_name

func Xsqlite3_bind_parameter_name(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)

C documentation

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

func Xsqlite3_bind_pointer(tls *libc.TLS, pStmt uintptr, i int32, pPtr uintptr, zPTtype uintptr, xDestructor uintptr) (r int32)

func Xsqlite3_bind_text

func Xsqlite3_bind_text(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData int32, xDel uintptr) (r int32)

func Xsqlite3_bind_text16

func Xsqlite3_bind_text16(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, n int32, xDel uintptr) (r int32)

func Xsqlite3_bind_text64

func Xsqlite3_bind_text64(tls *libc.TLS, pStmt uintptr, i int32, zData uintptr, nData Tsqlite3_uint64, xDel uintptr, enc uint8) (r int32)

func Xsqlite3_bind_value

func Xsqlite3_bind_value(tls *libc.TLS, pStmt uintptr, i int32, pValue uintptr) (r int32)

func Xsqlite3_bind_zeroblob

func Xsqlite3_bind_zeroblob(tls *libc.TLS, pStmt uintptr, i int32, n int32) (r int32)

func Xsqlite3_bind_zeroblob64

func Xsqlite3_bind_zeroblob64(tls *libc.TLS, pStmt uintptr, i int32, n Tsqlite3_uint64) (r int32)

func Xsqlite3_blob_bytes

func Xsqlite3_blob_bytes(tls *libc.TLS, pBlob uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pBlob uintptr) (r int32)

C documentation

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

func Xsqlite3_blob_open

func Xsqlite3_blob_open(tls *libc.TLS, db uintptr, zDb uintptr, zTable uintptr, zColumn uintptr, iRow Tsqlite_int64, wrFlag int32, ppBlob uintptr) (r int32)

C documentation

/*
** Open a blob handle.
*/

func Xsqlite3_blob_read

func Xsqlite3_blob_read(tls *libc.TLS, pBlob uintptr, z uintptr, n int32, iOffset int32) (r int32)

C documentation

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

func Xsqlite3_blob_reopen

func Xsqlite3_blob_reopen(tls *libc.TLS, pBlob uintptr, iRow Tsqlite3_int64) (r int32)

C documentation

/*
** 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 *libc.TLS, pBlob uintptr, z uintptr, n int32, iOffset int32) (r int32)

C documentation

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

func Xsqlite3_busy_handler

func Xsqlite3_busy_handler(tls *libc.TLS, db uintptr, xBusy uintptr, pArg uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, ms int32) (r int32)

C documentation

/*
** 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 *libc.TLS, xInit uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr) (r int32)

func Xsqlite3_clear_bindings

func Xsqlite3_clear_bindings(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_close

func Xsqlite3_close(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** Two variations on the public interface for closing a database
** connection. The sqlite3_close() version returns SQLITE_BUSY and
** leaves the connection open 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 *libc.TLS, db uintptr) (r int32)

func Xsqlite3_collation_needed

func Xsqlite3_collation_needed(tls *libc.TLS, db uintptr, pCollNeededArg uintptr, xCollNeeded uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, pCollNeededArg uintptr, xCollNeeded16 uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr, i int32) (r uintptr)

C documentation

/**************************** 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 *libc.TLS, pStmt uintptr, i int32) (r int32)

func Xsqlite3_column_bytes16

func Xsqlite3_column_bytes16(tls *libc.TLS, pStmt uintptr, i int32) (r int32)

func Xsqlite3_column_count

func Xsqlite3_column_count(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_column_database_name

func Xsqlite3_column_database_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

C documentation

/*
** Return the name of the database from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/

func Xsqlite3_column_database_name16

func Xsqlite3_column_database_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

func Xsqlite3_column_decltype

func Xsqlite3_column_decltype(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr, N int32) (r uintptr)

func Xsqlite3_column_double

func Xsqlite3_column_double(tls *libc.TLS, pStmt uintptr, i int32) (r float64)

func Xsqlite3_column_int

func Xsqlite3_column_int(tls *libc.TLS, pStmt uintptr, i int32) (r int32)

func Xsqlite3_column_name

func Xsqlite3_column_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr, N int32) (r uintptr)

func Xsqlite3_column_origin_name

func Xsqlite3_column_origin_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

C documentation

/*
** Return the name of the table column from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/

func Xsqlite3_column_origin_name16

func Xsqlite3_column_origin_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

func Xsqlite3_column_table_name

func Xsqlite3_column_table_name(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

C documentation

/*
** Return the name of the table from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/

func Xsqlite3_column_table_name16

func Xsqlite3_column_table_name16(tls *libc.TLS, pStmt uintptr, N int32) (r uintptr)

func Xsqlite3_column_text

func Xsqlite3_column_text(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)

func Xsqlite3_column_text16

func Xsqlite3_column_text16(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)

func Xsqlite3_column_type

func Xsqlite3_column_type(tls *libc.TLS, pStmt uintptr, i int32) (r int32)

func Xsqlite3_column_value

func Xsqlite3_column_value(tls *libc.TLS, pStmt uintptr, i int32) (r uintptr)

func Xsqlite3_commit_hook

func Xsqlite3_commit_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, N int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, zOptName uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, zSql uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, zSql uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, op int32, va uintptr) (r int32)

C documentation

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

func Xsqlite3_context_db_handle(tls *libc.TLS, p uintptr) (r uintptr)

C documentation

/*
** Extract the user data from a sqlite3_context structure and return a
** pointer to it.
**
** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
** returns a copy of the pointer to the database connection (the 1st
** parameter) of the sqlite3_create_function() and
** sqlite3_create_function16() routines that originally registered the
** application defined function.
*/

func Xsqlite3_create_collation

func Xsqlite3_create_collation(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, xCompare uintptr) (r int32)

C documentation

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

func Xsqlite3_create_collation16

func Xsqlite3_create_collation16(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, xCompare uintptr) (r int32)

C documentation

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

func Xsqlite3_create_collation_v2

func Xsqlite3_create_collation_v2(tls *libc.TLS, db uintptr, zName uintptr, enc int32, pCtx uintptr, xCompare uintptr, xDel uintptr) (r int32)

C documentation

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

func Xsqlite3_create_filename

func Xsqlite3_create_filename(tls *libc.TLS, zDatabase uintptr, zJournal uintptr, zWal uintptr, nParam int32, azParam uintptr) (r uintptr)

C documentation

/*
** Allocate memory to hold names for a database, journal file, WAL file,
** and query parameters.  The pointer returned is valid for use by
** sqlite3_filename_database() and sqlite3_uri_parameter() and related
** functions.
**
** Memory layout must be compatible with that generated by the pager
** and expected by sqlite3_uri_parameter() and databaseName().
*/

func Xsqlite3_create_function

func Xsqlite3_create_function(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, xSFunc uintptr, xStep uintptr, xFinal uintptr) (r int32)

C documentation

/*
** Create new user functions.
*/

func Xsqlite3_create_function16

func Xsqlite3_create_function16(tls *libc.TLS, db uintptr, zFunctionName uintptr, nArg int32, eTextRep int32, p uintptr, xSFunc uintptr, xStep uintptr, xFinal uintptr) (r int32)

func Xsqlite3_create_function_v2

func Xsqlite3_create_function_v2(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, xSFunc uintptr, xStep uintptr, xFinal uintptr, xDestroy uintptr) (r int32)

func Xsqlite3_create_module

func Xsqlite3_create_module(tls *libc.TLS, db uintptr, zName uintptr, pModule uintptr, pAux uintptr) (r int32)

C documentation

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

func Xsqlite3_create_module_v2

func Xsqlite3_create_module_v2(tls *libc.TLS, db uintptr, zName uintptr, pModule uintptr, pAux uintptr, xDestroy uintptr) (r int32)

C documentation

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

func Xsqlite3_create_window_function

func Xsqlite3_create_window_function(tls *libc.TLS, db uintptr, zFunc uintptr, nArg int32, enc int32, p uintptr, xStep uintptr, xFinal uintptr, xValue uintptr, xInverse uintptr, xDestroy uintptr) (r int32)

func Xsqlite3_data_count

func Xsqlite3_data_count(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_database_file_object

func Xsqlite3_database_file_object(tls *libc.TLS, zName uintptr) (r uintptr)

C documentation

/*
** Return the sqlite3_file for the main database given the name
** of the corresponding WAL or Journal name as passed into
** xOpen.
*/

func Xsqlite3_db_cacheflush

func Xsqlite3_db_cacheflush(tls *libc.TLS, db uintptr) (r int32)

C documentation

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

func Xsqlite3_db_config

func Xsqlite3_db_config(tls *libc.TLS, db uintptr, op int32, va uintptr) (r int32)

C documentation

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

func Xsqlite3_db_filename

func Xsqlite3_db_filename(tls *libc.TLS, db uintptr, zDbName uintptr) (r uintptr)

C documentation

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

func Xsqlite3_db_handle

func Xsqlite3_db_handle(tls *libc.TLS, pStmt uintptr) (r uintptr)

C documentation

/*
** Return the sqlite3* database handle to which the prepared statement given
** in the argument belongs.  This is the same database handle that was
** the first argument to the sqlite3_prepare() that was used to create
** the statement in the first place.
*/

func Xsqlite3_db_mutex

func Xsqlite3_db_mutex(tls *libc.TLS, db uintptr) (r uintptr)

C documentation

/*
** Return the mutex associated with a database connection.
*/

func Xsqlite3_db_name

func Xsqlite3_db_name(tls *libc.TLS, db uintptr, N int32) (r uintptr)

C documentation

/*
** Return the name of the N-th database schema.  Return NULL if N is out
** of range.
*/

func Xsqlite3_db_readonly

func Xsqlite3_db_readonly(tls *libc.TLS, db uintptr, zDbName uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr) (r int32)

C documentation

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

func Xsqlite3_db_status

func Xsqlite3_db_status(tls *libc.TLS, db uintptr, op int32, pCurrent uintptr, pHighwater uintptr, resetFlag int32) (r int32)

C documentation

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

func Xsqlite3_declare_vtab

func Xsqlite3_declare_vtab(tls *libc.TLS, db uintptr, zCreateTable uintptr) (r int32)

C documentation

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

func Xsqlite3_deserialize(tls *libc.TLS, db uintptr, zSchema uintptr, pData uintptr, szDb Tsqlite3_int64, szBuf Tsqlite3_int64, mFlags uint32) (r int32)

C documentation

/* Convert zSchema to a MemDB and initialize its content.
*/

func Xsqlite3_drop_modules

func Xsqlite3_drop_modules(tls *libc.TLS, db uintptr, azNames uintptr) (r int32)

C documentation

/*
** External API to drop all virtual-table modules, except those named
** on the azNames list.
*/

func Xsqlite3_enable_load_extension

func Xsqlite3_enable_load_extension(tls *libc.TLS, db uintptr, onoff int32) (r int32)

C documentation

/*
** 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 *libc.TLS, enable int32) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr) (r uintptr)

C documentation

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

func Xsqlite3_errmsg16

func Xsqlite3_errmsg16(tls *libc.TLS, db uintptr) (r uintptr)

C documentation

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

func Xsqlite3_error_offset

func Xsqlite3_error_offset(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** Return the byte offset of the most recent error
*/

func Xsqlite3_errstr

func Xsqlite3_errstr(tls *libc.TLS, rc int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, db uintptr, zSql uintptr, xCallback Tsqlite3_callback, pArg uintptr, pzErrMsg uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr) (r int32)

func Xsqlite3_extended_result_codes

func Xsqlite3_extended_result_codes(tls *libc.TLS, db uintptr, onoff int32) (r int32)

C documentation

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

func Xsqlite3_file_control

func Xsqlite3_file_control(tls *libc.TLS, db uintptr, zDbName uintptr, op int32, pArg uintptr) (r int32)

C documentation

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

func Xsqlite3_filename_database

func Xsqlite3_filename_database(tls *libc.TLS, zFilename uintptr) (r uintptr)

C documentation

/*
** Translate a filename that was handed to a VFS routine into the corresponding
** database, journal, or WAL file.
**
** It is an error to pass this routine a filename string that was not
** passed into the VFS from the SQLite core.  Doing so is similar to
** passing free() a pointer that was not obtained from malloc() - it is
** an error that we cannot easily detect but that will likely cause memory
** corruption.
*/

func Xsqlite3_filename_journal

func Xsqlite3_filename_journal(tls *libc.TLS, zFilename uintptr) (r uintptr)

func Xsqlite3_filename_wal

func Xsqlite3_filename_wal(tls *libc.TLS, zFilename uintptr) (r uintptr)

func Xsqlite3_finalize

func Xsqlite3_finalize(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, p uintptr)

C documentation

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

func Xsqlite3_free_filename

func Xsqlite3_free_filename(tls *libc.TLS, p uintptr)

C documentation

/*
** Free memory obtained from sqlite3_create_filename().  It is a severe
** error to call this routine with any parameter other than a pointer
** previously obtained from sqlite3_create_filename() or a NULL pointer.
*/

func Xsqlite3_free_table

func Xsqlite3_free_table(tls *libc.TLS, azResult uintptr)

C documentation

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

func Xsqlite3_get_autocommit

func Xsqlite3_get_autocommit(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pCtx uintptr, iArg int32) (r uintptr)

C documentation

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

func Xsqlite3_get_clientdata(tls *libc.TLS, db uintptr, zName uintptr) (r uintptr)

C documentation

/*
** Find existing client data.
*/

func Xsqlite3_get_table

func Xsqlite3_get_table(tls *libc.TLS, db uintptr, zSql uintptr, pazResult uintptr, pnRow uintptr, pnColumn uintptr, pzErrMsg uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS) (r int32)

C documentation

/*
** 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 *libc.TLS) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr)

C documentation

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

func Xsqlite3_is_interrupted

func Xsqlite3_is_interrupted(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** Return true or false depending on whether or not an interrupt is
** pending on connection db.
*/

func Xsqlite3_keyword_check

func Xsqlite3_keyword_check(tls *libc.TLS, zName uintptr, nName int32) (r int32)

func Xsqlite3_keyword_count

func Xsqlite3_keyword_count(tls *libc.TLS) (r int32)

func Xsqlite3_keyword_name

func Xsqlite3_keyword_name(tls *libc.TLS, i int32, pzName uintptr, pnName uintptr) (r int32)

func Xsqlite3_libversion

func Xsqlite3_libversion(tls *libc.TLS) (r uintptr)

C documentation

/* 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 *libc.TLS) (r int32)

C documentation

/* 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 *libc.TLS, db uintptr, limitId int32, newLimit int32) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zFile uintptr, zProc uintptr, pzErrMsg uintptr) (r int32)

func Xsqlite3_log

func Xsqlite3_log(tls *libc.TLS, iErrCode int32, zFormat uintptr, va uintptr)

C documentation

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

func Xsqlite3_malloc

func Xsqlite3_malloc(tls *libc.TLS, n int32) (r uintptr)

C documentation

/*
** 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 *libc.TLS, n Tsqlite3_uint64) (r uintptr)

func Xsqlite3_memory_alarm

func Xsqlite3_memory_alarm(tls *libc.TLS, xCallback uintptr, pArg uintptr, iThreshold Tsqlite3_int64) (r int32)

C documentation

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

func Xsqlite3_mprintf(tls *libc.TLS, zFormat uintptr, va uintptr) (r uintptr)

C documentation

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

func Xsqlite3_mutex_alloc

func Xsqlite3_mutex_alloc(tls *libc.TLS, id int32) (r uintptr)

C documentation

/*
** Retrieve a pointer to a static mutex or allocate a new dynamic one.
*/

func Xsqlite3_mutex_enter

func Xsqlite3_mutex_enter(tls *libc.TLS, p uintptr)

C documentation

/*
** 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 *libc.TLS, p uintptr)

C documentation

/*
** Free a dynamic mutex.
*/

func Xsqlite3_mutex_leave

func Xsqlite3_mutex_leave(tls *libc.TLS, p uintptr)

C documentation

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

func Xsqlite3_mutex_try(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pDb uintptr, pStmt uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, zFilename uintptr, ppDb uintptr) (r int32)

C documentation

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

func Xsqlite3_open16

func Xsqlite3_open16(tls *libc.TLS, zFilename uintptr, ppDb uintptr) (r int32)

C documentation

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

func Xsqlite3_open_v2

func Xsqlite3_open_v2(tls *libc.TLS, filename uintptr, ppDb uintptr, flags int32, zVfs uintptr) (r int32)

func Xsqlite3_os_end

func Xsqlite3_os_end(tls *libc.TLS) (r int32)

C documentation

/*
** 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 *libc.TLS) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zName uintptr, nArg int32) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, pzTail uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, pzTail uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, pzTail uintptr) (r int32)

func Xsqlite3_prepare16_v3

func Xsqlite3_prepare16_v3(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, prepFlags uint32, ppStmt uintptr, pzTail uintptr) (r int32)

func Xsqlite3_prepare_v2

func Xsqlite3_prepare_v2(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, ppStmt uintptr, pzTail uintptr) (r int32)

func Xsqlite3_prepare_v3

func Xsqlite3_prepare_v3(tls *libc.TLS, db uintptr, zSql uintptr, nBytes int32, prepFlags uint32, ppStmt uintptr, pzTail uintptr) (r int32)

func Xsqlite3_preupdate_blobwrite

func Xsqlite3_preupdate_blobwrite(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** This function is designed to be called from within a pre-update callback
** only.
*/

func Xsqlite3_preupdate_count

func Xsqlite3_preupdate_count(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** This function is called from within a pre-update callback to retrieve
** the number of columns in the row being updated, deleted or inserted.
*/

func Xsqlite3_preupdate_depth

func Xsqlite3_preupdate_depth(tls *libc.TLS, db uintptr) (r int32)

C documentation

/*
** This function is designed to be called from within a pre-update callback
** only. It returns zero if the change that caused the callback was made
** immediately by a user SQL statement. Or, if the change was made by a
** trigger program, it returns the number of trigger programs currently
** on the stack (1 for a top-level trigger, 2 for a trigger fired by a
** top-level trigger etc.).
**
** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL
** or SET DEFAULT action is considered a trigger.
*/

func Xsqlite3_preupdate_hook

func Xsqlite3_preupdate_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)

C documentation

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

func Xsqlite3_preupdate_new

func Xsqlite3_preupdate_new(tls *libc.TLS, db uintptr, iIdx int32, ppValue uintptr) (r int32)

C documentation

/*
** This function is called from within a pre-update callback to retrieve
** a field of the row currently being updated or inserted.
*/

func Xsqlite3_preupdate_old

func Xsqlite3_preupdate_old(tls *libc.TLS, db uintptr, iIdx int32, ppValue uintptr) (r int32)

C documentation

/*
** This function is called from within a pre-update callback to retrieve
** a field of the row currently being updated or deleted.
*/

func Xsqlite3_profile

func Xsqlite3_profile(tls *libc.TLS, db uintptr, xProfile uintptr, pArg uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, db uintptr, nOps int32, xProgress uintptr, pArg uintptr)

C documentation

/*
** 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 *libc.TLS, N int32, pBuf uintptr)

C documentation

/*
** Return N random bytes.
*/

func Xsqlite3_realloc

func Xsqlite3_realloc(tls *libc.TLS, pOld uintptr, n int32) (r uintptr)

C documentation

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

func Xsqlite3_realloc64

func Xsqlite3_realloc64(tls *libc.TLS, pOld uintptr, n Tsqlite3_uint64) (r uintptr)

func Xsqlite3_release_memory

func Xsqlite3_release_memory(tls *libc.TLS, n int32) (r int32)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS)

C documentation

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

func Xsqlite3_result_blob

func Xsqlite3_result_blob(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)

func Xsqlite3_result_blob64

func Xsqlite3_result_blob64(tls *libc.TLS, pCtx uintptr, z uintptr, n Tsqlite3_uint64, xDel uintptr)

func Xsqlite3_result_double

func Xsqlite3_result_double(tls *libc.TLS, pCtx uintptr, rVal float64)

func Xsqlite3_result_error

func Xsqlite3_result_error(tls *libc.TLS, pCtx uintptr, z uintptr, n int32)

func Xsqlite3_result_error16

func Xsqlite3_result_error16(tls *libc.TLS, pCtx uintptr, z uintptr, n int32)

func Xsqlite3_result_error_code

func Xsqlite3_result_error_code(tls *libc.TLS, pCtx uintptr, errCode int32)

func Xsqlite3_result_error_nomem

func Xsqlite3_result_error_nomem(tls *libc.TLS, pCtx uintptr)

C documentation

/* An SQLITE_NOMEM error. */

func Xsqlite3_result_error_toobig

func Xsqlite3_result_error_toobig(tls *libc.TLS, pCtx uintptr)

C documentation

/* Force an SQLITE_TOOBIG error. */

func Xsqlite3_result_int

func Xsqlite3_result_int(tls *libc.TLS, pCtx uintptr, iVal int32)

func Xsqlite3_result_int64

func Xsqlite3_result_int64(tls *libc.TLS, pCtx uintptr, iVal Ti64)

func Xsqlite3_result_null

func Xsqlite3_result_null(tls *libc.TLS, pCtx uintptr)

func Xsqlite3_result_pointer

func Xsqlite3_result_pointer(tls *libc.TLS, pCtx uintptr, pPtr uintptr, zPType uintptr, xDestructor uintptr)

func Xsqlite3_result_subtype

func Xsqlite3_result_subtype(tls *libc.TLS, pCtx uintptr, eSubtype uint32)

func Xsqlite3_result_text

func Xsqlite3_result_text(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)

func Xsqlite3_result_text16

func Xsqlite3_result_text16(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)

func Xsqlite3_result_text16be

func Xsqlite3_result_text16be(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)

func Xsqlite3_result_text16le

func Xsqlite3_result_text16le(tls *libc.TLS, pCtx uintptr, z uintptr, n int32, xDel uintptr)

func Xsqlite3_result_text64

func Xsqlite3_result_text64(tls *libc.TLS, pCtx uintptr, z uintptr, n Tsqlite3_uint64, xDel uintptr, enc uint8)

func Xsqlite3_result_value

func Xsqlite3_result_value(tls *libc.TLS, pCtx uintptr, pValue uintptr)

func Xsqlite3_result_zeroblob

func Xsqlite3_result_zeroblob(tls *libc.TLS, pCtx uintptr, n int32)

func Xsqlite3_result_zeroblob64

func Xsqlite3_result_zeroblob64(tls *libc.TLS, pCtx uintptr, n Tu64) (r int32)

func Xsqlite3_rollback_hook

func Xsqlite3_rollback_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)

C documentation

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

func Xsqlite3_rtree_geometry_callback

func Xsqlite3_rtree_geometry_callback(tls *libc.TLS, db uintptr, zGeom uintptr, xGeom uintptr, pContext uintptr) (r int32)

C documentation

/*
** Register a new geometry function for use with the r-tree MATCH operator.
*/

func Xsqlite3_rtree_query_callback

func Xsqlite3_rtree_query_callback(tls *libc.TLS, db uintptr, zQueryFunc uintptr, xQueryFunc uintptr, pContext uintptr, xDestructor uintptr) (r int32)

C documentation

/*
** Register a new 2nd-generation geometry function for use with the
** r-tree MATCH operator.
*/

func Xsqlite3_serialize

func Xsqlite3_serialize(tls *libc.TLS, db uintptr, zSchema uintptr, piSize uintptr, mFlags uint32) (r uintptr)

C documentation

/*
** Return the serialization of a database
*/

func Xsqlite3_set_authorizer

func Xsqlite3_set_authorizer(tls *libc.TLS, db uintptr, xAuth uintptr, pArg uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pCtx uintptr, iArg int32, pAux uintptr, xDelete uintptr)

C documentation

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

func Xsqlite3_set_clientdata(tls *libc.TLS, db uintptr, zName uintptr, pData uintptr, xDestructor uintptr) (r int32)

C documentation

/*
** Add new client data to a database connection.
*/

func Xsqlite3_set_last_insert_rowid

func Xsqlite3_set_last_insert_rowid(tls *libc.TLS, db uintptr, iRowid Tsqlite3_int64)

C documentation

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

func Xsqlite3_shutdown

func Xsqlite3_shutdown(tls *libc.TLS) (r int32)

C documentation

/*
** 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 *libc.TLS, ms int32) (r int32)

C documentation

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

func Xsqlite3_snapshot_cmp

func Xsqlite3_snapshot_cmp(tls *libc.TLS, p1 uintptr, p2 uintptr) (r int32)

C documentation

/*
** Return a +ve value if snapshot p1 is newer than p2. A -ve value if
** p1 is older than p2 and zero if p1 and p2 are the same snapshot.
*/

func Xsqlite3_snapshot_free

func Xsqlite3_snapshot_free(tls *libc.TLS, pSnapshot uintptr)

C documentation

/*
** Free a snapshot handle obtained from sqlite3_snapshot_get().
*/

func Xsqlite3_snapshot_get

func Xsqlite3_snapshot_get(tls *libc.TLS, db uintptr, zDb uintptr, ppSnapshot uintptr) (r int32)

C documentation

/*
** Obtain a snapshot handle for the snapshot of database zDb currently
** being read by handle db.
*/

func Xsqlite3_snapshot_open

func Xsqlite3_snapshot_open(tls *libc.TLS, db uintptr, zDb uintptr, pSnapshot uintptr) (r int32)

C documentation

/*
** Open a read-transaction on the snapshot identified by pSnapshot.
*/

func Xsqlite3_snapshot_recover

func Xsqlite3_snapshot_recover(tls *libc.TLS, db uintptr, zDb uintptr) (r int32)

C documentation

/*
** Recover as many snapshots as possible from the wal file associated with
** schema zDb of database db.
*/

func Xsqlite3_snprintf

func Xsqlite3_snprintf(tls *libc.TLS, n int32, zBuf uintptr, zFormat uintptr, va uintptr) (r uintptr)

func Xsqlite3_soft_heap_limit

func Xsqlite3_soft_heap_limit(tls *libc.TLS, n int32)

func Xsqlite3_sourceid

func Xsqlite3_sourceid(tls *libc.TLS) (r uintptr)

C documentation

/************** End of stmt.c ************************************************/
/* Return the source-id for this library */

func Xsqlite3_sql

func Xsqlite3_sql(tls *libc.TLS, pStmt uintptr) (r uintptr)

C documentation

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

func Xsqlite3_status

func Xsqlite3_status(tls *libc.TLS, op int32, pCurrent uintptr, pHighwater uintptr, resetFlag int32) (r int32)

func Xsqlite3_status64

func Xsqlite3_status64(tls *libc.TLS, op int32, pCurrent uintptr, pHighwater uintptr, resetFlag int32) (r int32)

C documentation

/*
** Query status information.
*/

func Xsqlite3_step

func Xsqlite3_step(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, pStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_stmt_explain

func Xsqlite3_stmt_explain(tls *libc.TLS, pStmt uintptr, eMode int32) (r int32)

C documentation

/*
** Set the explain mode for a statement.
*/

func Xsqlite3_stmt_isexplain

func Xsqlite3_stmt_isexplain(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

/*
** Return 1 if the statement is an EXPLAIN and return 2 if the
** statement is an EXPLAIN QUERY PLAN
*/

func Xsqlite3_stmt_readonly

func Xsqlite3_stmt_readonly(tls *libc.TLS, pStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_stmt_status

func Xsqlite3_stmt_status(tls *libc.TLS, pStmt uintptr, op int32, resetFlag int32) (r int32)

C documentation

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

func Xsqlite3_str_append

func Xsqlite3_str_append(tls *libc.TLS, p uintptr, z uintptr, N int32)

C documentation

/*
** Append N bytes of text from z to the StrAccum object.  Increase the
** size of the memory allocation for StrAccum if necessary.
*/

func Xsqlite3_str_appendall

func Xsqlite3_str_appendall(tls *libc.TLS, p uintptr, z uintptr)

C documentation

/*
** Append the complete text of zero-terminated string z[] to the p string.
*/

func Xsqlite3_str_appendchar

func Xsqlite3_str_appendchar(tls *libc.TLS, p uintptr, N int32, c int8)

C documentation

/*
** Append N copies of character c to the given string buffer.
*/

func Xsqlite3_str_appendf

func Xsqlite3_str_appendf(tls *libc.TLS, p uintptr, zFormat uintptr, va uintptr)

C documentation

/*
** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
*/

func Xsqlite3_str_errcode

func Xsqlite3_str_errcode(tls *libc.TLS, p uintptr) (r int32)

C documentation

/* Return any error code associated with p */

func Xsqlite3_str_finish

func Xsqlite3_str_finish(tls *libc.TLS, p uintptr) (r uintptr)

C documentation

/* Finalize a string created using sqlite3_str_new().
*/

func Xsqlite3_str_length

func Xsqlite3_str_length(tls *libc.TLS, p uintptr) (r int32)

C documentation

/* Return the current length of p in bytes */

func Xsqlite3_str_new

func Xsqlite3_str_new(tls *libc.TLS, db uintptr) (r uintptr)

C documentation

/* Allocate and initialize a new dynamic string object */

func Xsqlite3_str_reset

func Xsqlite3_str_reset(tls *libc.TLS, p uintptr)

C documentation

/*
** Reset an StrAccum string.  Reclaim all malloced memory.
*/

func Xsqlite3_str_value

func Xsqlite3_str_value(tls *libc.TLS, p uintptr) (r uintptr)

C documentation

/* Return the current value for p */

func Xsqlite3_str_vappendf

func Xsqlite3_str_vappendf(tls *libc.TLS, pAccum uintptr, fmt uintptr, ap Tva_list)

C documentation

/*
** Render a string given by "fmt" into the StrAccum object.
*/

func Xsqlite3_strglob

func Xsqlite3_strglob(tls *libc.TLS, zGlobPattern uintptr, zString uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, zLeft uintptr, zRight uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, zPattern uintptr, zStr uintptr, esc uint32) (r int32)

C documentation

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

func Xsqlite3_strnicmp

func Xsqlite3_strnicmp(tls *libc.TLS, zLeft uintptr, zRight uintptr, N int32) (r int32)

func Xsqlite3_system_errno

func Xsqlite3_system_errno(tls *libc.TLS, db uintptr) (r int32)

func Xsqlite3_table_column_metadata

func Xsqlite3_table_column_metadata(tls *libc.TLS, db uintptr, zDbName uintptr, zTableName uintptr, zColumnName uintptr, pzDataType uintptr, pzCollSeq uintptr, pNotNull uintptr, pPrimaryKey uintptr, pAutoinc uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, op int32, va uintptr) (r int32)

C documentation

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

func Xsqlite3_thread_cleanup

func Xsqlite3_thread_cleanup(tls *libc.TLS)

C documentation

/*
** 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 *libc.TLS) (r int32)

C documentation

/* 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 *libc.TLS, db uintptr) (r int32)

func Xsqlite3_trace

func Xsqlite3_trace(tls *libc.TLS, db uintptr, xTrace uintptr, pArg uintptr) (r uintptr)

C documentation

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

func Xsqlite3_trace_v2

func Xsqlite3_trace_v2(tls *libc.TLS, db uintptr, mTrace uint32, xTrace uintptr, pArg uintptr) (r int32)

C documentation

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

func Xsqlite3_transfer_bindings

func Xsqlite3_transfer_bindings(tls *libc.TLS, pFromStmt uintptr, pToStmt uintptr) (r int32)

C documentation

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

func Xsqlite3_txn_state(tls *libc.TLS, db uintptr, zSchema uintptr) (r int32)

C documentation

/*
** Return the transaction state for a single databse, or the maximum
** transaction state over all attached databases if zSchema is null.
*/

func Xsqlite3_unlock_notify

func Xsqlite3_unlock_notify(tls *libc.TLS, db uintptr, xNotify uintptr, _pArg uintptr) (r int32)

C documentation

/*
** Register an unlock-notify callback.
**
** This is called after connection "db" has attempted some operation
** but has received an SQLITE_LOCKED error because another connection
** (call it pOther) in the same process was busy using the same shared
** cache.  pOther is found by looking at db->pBlockingConnection.
**
** If there is no blocking connection, the callback is invoked immediately,
** before this routine returns.
**
** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
** a deadlock.
**
** Otherwise, make arrangements to invoke xNotify when pOther drops
** its locks.
**
** Each call to this routine overrides any prior callbacks registered
** on the same "db".  If xNotify==0 then any prior callbacks are immediately
** cancelled.
*/

func Xsqlite3_update_hook

func Xsqlite3_update_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, zFilename uintptr, zParam uintptr, bDflt int32) (r int32)

C documentation

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

func Xsqlite3_uri_key

func Xsqlite3_uri_key(tls *libc.TLS, zFilename uintptr, N int32) (r uintptr)

C documentation

/*
** Return a pointer to the name of Nth query parameter of the filename.
*/

func Xsqlite3_uri_parameter

func Xsqlite3_uri_parameter(tls *libc.TLS, zFilename uintptr, zParam uintptr) (r uintptr)

C documentation

/*
** 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 *libc.TLS, p uintptr) (r uintptr)

C documentation

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

func Xsqlite3_value_blob

func Xsqlite3_value_blob(tls *libc.TLS, pVal uintptr) (r uintptr)

C documentation

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

func Xsqlite3_value_bytes

func Xsqlite3_value_bytes(tls *libc.TLS, pVal uintptr) (r int32)

func Xsqlite3_value_bytes16

func Xsqlite3_value_bytes16(tls *libc.TLS, pVal uintptr) (r int32)

func Xsqlite3_value_double

func Xsqlite3_value_double(tls *libc.TLS, pVal uintptr) (r float64)

func Xsqlite3_value_dup

func Xsqlite3_value_dup(tls *libc.TLS, pOrig uintptr) (r uintptr)

C documentation

/* Make a copy of an sqlite3_value object
*/

func Xsqlite3_value_encoding

func Xsqlite3_value_encoding(tls *libc.TLS, pVal uintptr) (r int32)

func Xsqlite3_value_free

func Xsqlite3_value_free(tls *libc.TLS, pOld uintptr)

C documentation

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

func Xsqlite3_value_frombind

func Xsqlite3_value_frombind(tls *libc.TLS, pVal uintptr) (r int32)

C documentation

/* Return true if a parameter value originated from an sqlite3_bind() */

func Xsqlite3_value_int

func Xsqlite3_value_int(tls *libc.TLS, pVal uintptr) (r int32)

func Xsqlite3_value_nochange

func Xsqlite3_value_nochange(tls *libc.TLS, pVal uintptr) (r int32)

C documentation

/* Return true if a parameter to xUpdate represents an unchanged column */

func Xsqlite3_value_numeric_type

func Xsqlite3_value_numeric_type(tls *libc.TLS, pVal uintptr) (r int32)

C documentation

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

func Xsqlite3_value_pointer(tls *libc.TLS, pVal uintptr, zPType uintptr) (r uintptr)

func Xsqlite3_value_subtype

func Xsqlite3_value_subtype(tls *libc.TLS, pVal uintptr) (r uint32)

func Xsqlite3_value_text

func Xsqlite3_value_text(tls *libc.TLS, pVal uintptr) (r uintptr)

func Xsqlite3_value_text16

func Xsqlite3_value_text16(tls *libc.TLS, pVal uintptr) (r uintptr)

func Xsqlite3_value_text16be

func Xsqlite3_value_text16be(tls *libc.TLS, pVal uintptr) (r uintptr)

func Xsqlite3_value_text16le

func Xsqlite3_value_text16le(tls *libc.TLS, pVal uintptr) (r uintptr)

func Xsqlite3_value_type

func Xsqlite3_value_type(tls *libc.TLS, pVal uintptr) (r int32)

C documentation

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

func Xsqlite3_vfs_find(tls *libc.TLS, zVfs uintptr) (r uintptr)

C documentation

/*
** Locate a VFS by name.  If no name is given, simply return the
** first VFS on the list.
*/

func Xsqlite3_vfs_register

func Xsqlite3_vfs_register(tls *libc.TLS, pVfs uintptr, makeDflt int32) (r int32)

C documentation

/*
** 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 *libc.TLS, pVfs uintptr) (r int32)

C documentation

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

func Xsqlite3_vmprintf

func Xsqlite3_vmprintf(tls *libc.TLS, zFormat uintptr, ap Tva_list) (r uintptr)

C documentation

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

func Xsqlite3_vsnprintf

func Xsqlite3_vsnprintf(tls *libc.TLS, n int32, zBuf uintptr, zFormat uintptr, ap Tva_list) (r uintptr)

C documentation

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

func Xsqlite3_vtab_collation(tls *libc.TLS, pIdxInfo uintptr, iCons int32) (r uintptr)

C documentation

/*
** Return the collating sequence for a constraint passed into xBestIndex.
**
** pIdxInfo must be an sqlite3_index_info structure passed into xBestIndex.
** This routine depends on there being a HiddenIndexInfo structure immediately
** following the sqlite3_index_info structure.
**
** Return a pointer to the collation name:
**
**    1. If there is an explicit COLLATE operator on the constraint, return it.
**
**    2. Else, if the column has an alternative collation, return that.
**
**    3. Otherwise, return "BINARY".
*/

func Xsqlite3_vtab_config

func Xsqlite3_vtab_config(tls *libc.TLS, db uintptr, op int32, va uintptr) (r int32)

C documentation

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

func Xsqlite3_vtab_distinct(tls *libc.TLS, pIdxInfo uintptr) (r int32)

C documentation

/*
** Return true if ORDER BY clause may be handled as DISTINCT.
*/

func Xsqlite3_vtab_in

func Xsqlite3_vtab_in(tls *libc.TLS, pIdxInfo uintptr, iCons int32, bHandle int32) (r int32)

C documentation

/*
** Return true if constraint iCons is really an IN(...) constraint, or
** false otherwise. If iCons is an IN(...) constraint, set (if bHandle!=0)
** or clear (if bHandle==0) the flag to handle it using an iterator.
*/

func Xsqlite3_vtab_in_first

func Xsqlite3_vtab_in_first(tls *libc.TLS, pVal uintptr, ppOut uintptr) (r int32)

C documentation

/*
** Set the iterator value pVal to point to the first value in the set.
** Set (*ppOut) to point to this value before returning.
*/

func Xsqlite3_vtab_in_next

func Xsqlite3_vtab_in_next(tls *libc.TLS, pVal uintptr, ppOut uintptr) (r int32)

C documentation

/*
** Set the iterator value pVal to point to the next value in the set.
** Set (*ppOut) to point to this value before returning.
*/

func Xsqlite3_vtab_nochange

func Xsqlite3_vtab_nochange(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** If this routine is invoked from within an xColumn method of a virtual
** table, then it returns true if and only if the the call is during an
** UPDATE operation and the value of the column will not be modified
** by the UPDATE.
**
** If this routine is called from any context other than within the
** xColumn method of a virtual table, then the return value is meaningless
** and arbitrary.
**
** Virtual table implements might use this routine to optimize their
** performance by substituting a NULL result, or some other light-weight
** value, as a signal to the xUpdate routine that the column is unchanged.
*/

func Xsqlite3_vtab_on_conflict

func Xsqlite3_vtab_on_conflict(tls *libc.TLS, db uintptr) (r int32)

C documentation

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

func Xsqlite3_vtab_rhs_value(tls *libc.TLS, pIdxInfo uintptr, iCons int32, ppVal uintptr) (r int32)

C documentation

/*
** This interface is callable from within the xBestIndex callback only.
**
** If possible, set (*ppVal) to point to an object containing the value
** on the right-hand-side of constraint iCons.
*/

func Xsqlite3_wal_autocheckpoint

func Xsqlite3_wal_autocheckpoint(tls *libc.TLS, db uintptr, nFrame int32) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zDb uintptr) (r int32)

C documentation

/*
** 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 *libc.TLS, db uintptr, zDb uintptr, eMode int32, pnLog uintptr, pnCkpt uintptr) (r int32)

C documentation

/*
** Checkpoint database zDb.
*/

func Xsqlite3_wal_hook

func Xsqlite3_wal_hook(tls *libc.TLS, db uintptr, xCallback uintptr, pArg uintptr) (r uintptr)

C documentation

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

func Xsqlite3changegroup_add

func Xsqlite3changegroup_add(tls *libc.TLS, pGrp uintptr, nData int32, pData uintptr) (r int32)

C documentation

/*
** Add the changeset currently stored in buffer pData, size nData bytes,
** to changeset-group p.
*/

func Xsqlite3changegroup_add_change

func Xsqlite3changegroup_add_change(tls *libc.TLS, pGrp uintptr, pIter uintptr) (r int32)

C documentation

/*
** Add a single change to a changeset-group.
*/

func Xsqlite3changegroup_add_strm

func Xsqlite3changegroup_add_strm(tls *libc.TLS, pGrp uintptr, xInput uintptr, pIn uintptr) (r int32)

C documentation

/*
** Streaming versions of changegroup_add().
*/

func Xsqlite3changegroup_delete

func Xsqlite3changegroup_delete(tls *libc.TLS, pGrp uintptr)

C documentation

/*
** Delete a changegroup object.
*/

func Xsqlite3changegroup_new

func Xsqlite3changegroup_new(tls *libc.TLS, pp uintptr) (r int32)

C documentation

/*
** Allocate a new, empty, sqlite3_changegroup.
*/

func Xsqlite3changegroup_output

func Xsqlite3changegroup_output(tls *libc.TLS, pGrp uintptr, pnData uintptr, ppData uintptr) (r int32)

C documentation

/*
** Obtain a buffer containing a changeset representing the concatenation
** of all changesets added to the group so far.
*/

func Xsqlite3changegroup_output_strm

func Xsqlite3changegroup_output_strm(tls *libc.TLS, pGrp uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Streaming versions of changegroup_output().
*/

func Xsqlite3changegroup_schema

func Xsqlite3changegroup_schema(tls *libc.TLS, pGrp uintptr, db uintptr, zDb uintptr) (r int32)

C documentation

/*
** Provide a database schema to the changegroup object.
*/

func Xsqlite3changeset_apply

func Xsqlite3changeset_apply(tls *libc.TLS, db uintptr, nChangeset int32, pChangeset uintptr, xFilter uintptr, xConflict uintptr, pCtx uintptr) (r int32)

C documentation

/*
** Apply the changeset passed via pChangeset/nChangeset to the main database
** attached to handle "db". Invoke the supplied conflict handler callback
** to resolve any conflicts encountered while applying the change.
*/

func Xsqlite3changeset_apply_strm

func Xsqlite3changeset_apply_strm(tls *libc.TLS, db uintptr, xInput uintptr, pIn uintptr, xFilter uintptr, xConflict uintptr, pCtx uintptr) (r int32)

func Xsqlite3changeset_apply_v2

func Xsqlite3changeset_apply_v2(tls *libc.TLS, db uintptr, nChangeset int32, pChangeset uintptr, xFilter uintptr, xConflict uintptr, pCtx uintptr, ppRebase uintptr, pnRebase uintptr, flags int32) (r int32)

C documentation

/*
** Apply the changeset passed via pChangeset/nChangeset to the main
** database attached to handle "db".
*/

func Xsqlite3changeset_apply_v2_strm

func Xsqlite3changeset_apply_v2_strm(tls *libc.TLS, db uintptr, xInput uintptr, pIn uintptr, xFilter uintptr, xConflict uintptr, pCtx uintptr, ppRebase uintptr, pnRebase uintptr, flags int32) (r int32)

C documentation

/*
** Apply the changeset passed via xInput/pIn to the main database
** attached to handle "db". Invoke the supplied conflict handler callback
** to resolve any conflicts encountered while applying the change.
*/

func Xsqlite3changeset_concat

func Xsqlite3changeset_concat(tls *libc.TLS, nLeft int32, pLeft uintptr, nRight int32, pRight uintptr, pnOut uintptr, ppOut uintptr) (r int32)

C documentation

/*
** Combine two changesets together.
*/

func Xsqlite3changeset_concat_strm

func Xsqlite3changeset_concat_strm(tls *libc.TLS, xInputA uintptr, pInA uintptr, xInputB uintptr, pInB uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Streaming version of sqlite3changeset_concat().
*/

func Xsqlite3changeset_conflict

func Xsqlite3changeset_conflict(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)

C documentation

/*
** This function may only be called with a changeset iterator that has been
** passed to an SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT
** conflict-handler function. Otherwise, SQLITE_MISUSE is returned.
**
** If successful, *ppValue is set to point to an sqlite3_value structure
** containing the iVal'th value of the conflicting record.
**
** If value iVal is out-of-range or some other error occurs, an SQLite error
** code is returned. Otherwise, SQLITE_OK.
*/

func Xsqlite3changeset_finalize

func Xsqlite3changeset_finalize(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** Finalize an iterator allocated with sqlite3changeset_start().
**
** This function may not be called on iterators passed to a conflict handler
** callback by changeset_apply().
*/

func Xsqlite3changeset_fk_conflicts

func Xsqlite3changeset_fk_conflicts(tls *libc.TLS, pIter uintptr, pnOut uintptr) (r int32)

C documentation

/*
** This function may only be called with an iterator passed to an
** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case
** it sets the output variable to the total number of known foreign key
** violations in the destination database and returns SQLITE_OK.
**
** In all other cases this function returns SQLITE_MISUSE.
*/

func Xsqlite3changeset_invert

func Xsqlite3changeset_invert(tls *libc.TLS, nChangeset int32, pChangeset uintptr, pnInverted uintptr, ppInverted uintptr) (r int32)

C documentation

/*
** Invert a changeset object.
*/

func Xsqlite3changeset_invert_strm

func Xsqlite3changeset_invert_strm(tls *libc.TLS, xInput uintptr, pIn uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Streaming version of sqlite3changeset_invert().
*/

func Xsqlite3changeset_new

func Xsqlite3changeset_new(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)

C documentation

/*
** This function may only be called while the iterator is pointing to an
** SQLITE_UPDATE or SQLITE_INSERT change (see sqlite3changeset_op()).
** Otherwise, SQLITE_MISUSE is returned.
**
** It sets *ppValue to point to an sqlite3_value structure containing the
** iVal'th value in the new.* record. Or, if that particular value is not
** included in the record (because the change is an UPDATE and the field
** was not modified), set *ppValue to NULL.
**
** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
** not modified. Otherwise, SQLITE_OK.
*/

func Xsqlite3changeset_next

func Xsqlite3changeset_next(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** Advance an iterator created by sqlite3changeset_start() to the next
** change in the changeset. This function may return SQLITE_ROW, SQLITE_DONE
** or SQLITE_CORRUPT.
**
** This function may not be called on iterators passed to a conflict handler
** callback by changeset_apply().
*/

func Xsqlite3changeset_old

func Xsqlite3changeset_old(tls *libc.TLS, pIter uintptr, iVal int32, ppValue uintptr) (r int32)

C documentation

/*
** This function may only be called while the iterator is pointing to an
** SQLITE_UPDATE or SQLITE_DELETE change (see sqlite3changeset_op()).
** Otherwise, SQLITE_MISUSE is returned.
**
** It sets *ppValue to point to an sqlite3_value structure containing the
** iVal'th value in the old.* record. Or, if that particular value is not
** included in the record (because the change is an UPDATE and the field
** was not modified and is not a PK column), set *ppValue to NULL.
**
** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
** not modified. Otherwise, SQLITE_OK.
*/

func Xsqlite3changeset_op

func Xsqlite3changeset_op(tls *libc.TLS, pIter uintptr, pzTab uintptr, pnCol uintptr, pOp uintptr, pbIndirect uintptr) (r int32)

C documentation

/*
** The following function extracts information on the current change
** from a changeset iterator. It may only be called after changeset_next()
** has returned SQLITE_ROW.
*/

func Xsqlite3changeset_pk

func Xsqlite3changeset_pk(tls *libc.TLS, pIter uintptr, pabPK uintptr, pnCol uintptr) (r int32)

C documentation

/*
** Return information regarding the PRIMARY KEY and number of columns in
** the database table affected by the change that pIter currently points
** to. This function may only be called after changeset_next() returns
** SQLITE_ROW.
*/

func Xsqlite3changeset_start

func Xsqlite3changeset_start(tls *libc.TLS, pp uintptr, nChangeset int32, pChangeset uintptr) (r int32)

C documentation

/*
** Create an iterator used to iterate through the contents of a changeset.
*/

func Xsqlite3changeset_start_strm

func Xsqlite3changeset_start_strm(tls *libc.TLS, pp uintptr, xInput uintptr, pIn uintptr) (r int32)

C documentation

/*
** Streaming version of sqlite3changeset_start().
*/

func Xsqlite3changeset_start_v2

func Xsqlite3changeset_start_v2(tls *libc.TLS, pp uintptr, nChangeset int32, pChangeset uintptr, flags int32) (r int32)

func Xsqlite3changeset_start_v2_strm

func Xsqlite3changeset_start_v2_strm(tls *libc.TLS, pp uintptr, xInput uintptr, pIn uintptr, flags int32) (r int32)

func Xsqlite3rbu_bp_progress

func Xsqlite3rbu_bp_progress(tls *libc.TLS, p uintptr, pnOne uintptr, pnTwo uintptr)

C documentation

/*
** Return permyriadage progress indications for the two main stages of
** an RBU update.
*/

func Xsqlite3rbu_close

func Xsqlite3rbu_close(tls *libc.TLS, p uintptr, pzErrmsg uintptr) (r int32)

C documentation

/*
** Close the RBU handle.
*/

func Xsqlite3rbu_create_vfs

func Xsqlite3rbu_create_vfs(tls *libc.TLS, zName uintptr, zParent uintptr) (r int32)

C documentation

/*
** Create an RBU VFS named zName that accesses the underlying file-system
** via existing VFS zParent. The new object is registered as a non-default
** VFS with SQLite before returning.
*/

func Xsqlite3rbu_db

func Xsqlite3rbu_db(tls *libc.TLS, pRbu uintptr, bRbu int32) (r uintptr)

C documentation

/*
** Return the database handle used by pRbu.
*/

func Xsqlite3rbu_destroy_vfs

func Xsqlite3rbu_destroy_vfs(tls *libc.TLS, zName uintptr)

C documentation

/*
** Deregister and destroy an RBU vfs created by an earlier call to
** sqlite3rbu_create_vfs().
*/

func Xsqlite3rbu_open

func Xsqlite3rbu_open(tls *libc.TLS, zTarget uintptr, zRbu uintptr, zState uintptr) (r uintptr)

C documentation

/*
** Open and return a new RBU handle.
*/

func Xsqlite3rbu_rename_handler

func Xsqlite3rbu_rename_handler(tls *libc.TLS, pRbu uintptr, pArg uintptr, xRename uintptr)

func Xsqlite3rbu_savestate

func Xsqlite3rbu_savestate(tls *libc.TLS, p uintptr) (r int32)

func Xsqlite3rbu_state

func Xsqlite3rbu_state(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** Return the current state of the RBU vacuum or update operation.
*/

func Xsqlite3rbu_step

func Xsqlite3rbu_step(tls *libc.TLS, p uintptr) (r int32)

C documentation

/*
** Step the RBU object.
*/

func Xsqlite3rbu_vacuum

func Xsqlite3rbu_vacuum(tls *libc.TLS, zTarget uintptr, zState uintptr) (r uintptr)

C documentation

/*
** Open a handle to begin or resume an RBU VACUUM operation.
*/

func Xsqlite3rebaser_configure

func Xsqlite3rebaser_configure(tls *libc.TLS, p uintptr, nRebase int32, pRebase uintptr) (r int32)

C documentation

/*
** Call this one or more times to configure a rebaser.
*/

func Xsqlite3rebaser_create

func Xsqlite3rebaser_create(tls *libc.TLS, ppNew uintptr) (r int32)

C documentation

/*
** Create a new rebaser object.
*/

func Xsqlite3rebaser_delete

func Xsqlite3rebaser_delete(tls *libc.TLS, p uintptr)

C documentation

/*
** Destroy a rebaser object
*/

func Xsqlite3rebaser_rebase

func Xsqlite3rebaser_rebase(tls *libc.TLS, p uintptr, nIn int32, pIn uintptr, pnOut uintptr, ppOut uintptr) (r int32)

C documentation

/*
** Rebase a changeset according to current rebaser configuration
*/

func Xsqlite3rebaser_rebase_strm

func Xsqlite3rebaser_rebase_strm(tls *libc.TLS, p uintptr, xInput uintptr, pIn uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Rebase a changeset according to current rebaser configuration
*/

func Xsqlite3session_attach

func Xsqlite3session_attach(tls *libc.TLS, pSession uintptr, zName uintptr) (r int32)

C documentation

/*
** Attach a table to a session. All subsequent changes made to the table
** while the session object is enabled will be recorded.
**
** Only tables that have a PRIMARY KEY defined may be attached. It does
** not matter if the PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias)
** or not.
*/

func Xsqlite3session_changeset

func Xsqlite3session_changeset(tls *libc.TLS, pSession uintptr, pnChangeset uintptr, ppChangeset uintptr) (r int32)

C documentation

/*
** Obtain a changeset object containing all changes recorded by the
** session object passed as the first argument.
**
** It is the responsibility of the caller to eventually free the buffer
** using sqlite3_free().
*/

func Xsqlite3session_changeset_strm

func Xsqlite3session_changeset_strm(tls *libc.TLS, pSession uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Streaming version of sqlite3session_changeset().
*/

func Xsqlite3session_config

func Xsqlite3session_config(tls *libc.TLS, op int32, pArg uintptr) (r int32)

C documentation

/*
** Global configuration
*/

func Xsqlite3session_create

func Xsqlite3session_create(tls *libc.TLS, db uintptr, zDb uintptr, ppSession uintptr) (r int32)

C documentation

/*
** Create a session object. This session object will record changes to
** database zDb attached to connection db.
*/

func Xsqlite3session_delete

func Xsqlite3session_delete(tls *libc.TLS, pSession uintptr)

C documentation

/*
** Delete a session object previously allocated using sqlite3session_create().
*/

func Xsqlite3session_diff

func Xsqlite3session_diff(tls *libc.TLS, pSession uintptr, zFrom uintptr, zTbl uintptr, pzErrMsg uintptr) (r int32)

func Xsqlite3session_enable

func Xsqlite3session_enable(tls *libc.TLS, pSession uintptr, bEnable int32) (r int32)

C documentation

/*
** Enable or disable the session object passed as the first argument.
*/

func Xsqlite3session_indirect

func Xsqlite3session_indirect(tls *libc.TLS, pSession uintptr, bIndirect int32) (r int32)

C documentation

/*
** Enable or disable the session object passed as the first argument.
*/

func Xsqlite3session_isempty

func Xsqlite3session_isempty(tls *libc.TLS, pSession uintptr) (r int32)

C documentation

/*
** Return true if there have been no changes to monitored tables recorded
** by the session object passed as the only argument.
*/

func Xsqlite3session_object_config

func Xsqlite3session_object_config(tls *libc.TLS, pSession uintptr, op int32, pArg uintptr) (r int32)

C documentation

/*
** Configure the session object passed as the first argument.
*/

func Xsqlite3session_patchset

func Xsqlite3session_patchset(tls *libc.TLS, pSession uintptr, pnPatchset uintptr, ppPatchset uintptr) (r int32)

C documentation

/*
** Obtain a patchset object containing all changes recorded by the
** session object passed as the first argument.
**
** It is the responsibility of the caller to eventually free the buffer
** using sqlite3_free().
*/

func Xsqlite3session_patchset_strm

func Xsqlite3session_patchset_strm(tls *libc.TLS, pSession uintptr, xOutput uintptr, pOut uintptr) (r int32)

C documentation

/*
** Streaming version of sqlite3session_patchset().
*/

func Xsqlite3session_table_filter

func Xsqlite3session_table_filter(tls *libc.TLS, pSession uintptr, xFilter uintptr, pCtx uintptr)

C documentation

/*
** Set a table filter on a Session Object.
*/

Types

type AggInfo

type AggInfo = TAggInfo

type AggInfo1

type AggInfo1 = TAggInfo1

type AggInfo_col

type AggInfo_col = TAggInfo_col

type AggInfo_func

type AggInfo_func = TAggInfo_func

type AsciiTokenizer

type AsciiTokenizer = TAsciiTokenizer

type AsciiTokenizer1

type AsciiTokenizer1 = TAsciiTokenizer1

type AuthContext

type AuthContext = TAuthContext

type AuthContext1

type AuthContext1 = TAuthContext1

type AutoincInfo

type AutoincInfo = TAutoincInfo

type AutoincInfo1

type AutoincInfo1 = TAutoincInfo1

type AuxData

type AuxData = TAuxData

type AuxData1

type AuxData1 = TAuxData1

type BenignMallocHooks

type BenignMallocHooks = TBenignMallocHooks

type BenignMallocHooks1

type BenignMallocHooks1 = TBenignMallocHooks1

type Bitmask

type Bitmask = TBitmask

type Bitvec

type Bitvec = TBitvec

type Bitvec1

type Bitvec1 = TBitvec1

type Bool

type Bool = TBool

type BtCursor

type BtCursor = TBtCursor

type BtCursor1

type BtCursor1 = TBtCursor1

type BtLock

type BtLock = TBtLock

type BtLock1

type BtLock1 = TBtLock1

type BtShared

type BtShared = TBtShared

type BtShared1

type BtShared1 = TBtShared1

type Btree

type Btree = TBtree

type Btree1

type Btree1 = TBtree1

type BtreePayload

type BtreePayload = TBtreePayload

type BtreePayload1

type BtreePayload1 = TBtreePayload1

type BusyHandler

type BusyHandler = TBusyHandler

type BusyHandler1

type BusyHandler1 = TBusyHandler1

type CInstIter

type CInstIter = TCInstIter

type CInstIter1

type CInstIter1 = TCInstIter1

type CallCount

type CallCount = TCallCount

type CellArray

type CellArray = TCellArray

type CellArray1

type CellArray1 = TCellArray1

type CellInfo

type CellInfo = TCellInfo

type CellInfo1

type CellInfo1 = TCellInfo1

type CollSeq

type CollSeq = TCollSeq

type CollSeq1

type CollSeq1 = TCollSeq1

type Column

type Column = TColumn

type Column1

type Column1 = TColumn1

type CountCtx

type CountCtx = TCountCtx

type CountCtx1

type CountCtx1 = TCountCtx1

type CoveringIndexCheck

type CoveringIndexCheck = TCoveringIndexCheck

type CoveringIndexCheck1

type CoveringIndexCheck1 = TCoveringIndexCheck1

type Cte

type Cte = TCte

type Cte1

type Cte1 = TCte1

type CteUse

type CteUse = TCteUse

type CteUse1

type CteUse1 = TCteUse1

type DateTime

type DateTime = TDateTime

type DateTime1

type DateTime1 = TDateTime1

type Db

type Db = TDb

type Db1

type Db1 = TDb1

type DbClientData

type DbClientData = TDbClientData

type DbClientData1

type DbClientData1 = TDbClientData1

type DbFixer

type DbFixer = TDbFixer

type DbFixer1

type DbFixer1 = TDbFixer1

type DbPage

type DbPage = TDbPage

type DbPath

type DbPath = TDbPath

type DbPath1

type DbPath1 = TDbPath1

type DblquoteStr

type DblquoteStr = TDblquoteStr

type DblquoteStr1

type DblquoteStr1 = TDblquoteStr1

type DistinctCtx

type DistinctCtx = TDistinctCtx

type DistinctCtx1

type DistinctCtx1 = TDistinctCtx1

type Dl_info

type Dl_info = TDl_info

type EdupBuf

type EdupBuf = TEdupBuf

type EdupBuf1

type EdupBuf1 = TEdupBuf1

type Expr

type Expr = TExpr

type Expr1

type Expr1 = TExpr1

type ExprList

type ExprList = TExprList

type ExprList1

type ExprList1 = TExprList1

type ExprList_item

type ExprList_item = TExprList_item

type FKey

type FKey = TFKey

type FKey1

type FKey1 = TFKey1

type FileChunk

type FileChunk = TFileChunk

type FileChunk1

type FileChunk1 = TFileChunk1

type FilePoint

type FilePoint = TFilePoint

type FilePoint1

type FilePoint1 = TFilePoint1

type FpDecode

type FpDecode = TFpDecode

type FpDecode1

type FpDecode1 = TFpDecode1

type FrameBound

type FrameBound = TFrameBound

type Fts5Auxdata

type Fts5Auxdata = TFts5Auxdata

type Fts5Auxdata1

type Fts5Auxdata1 = TFts5Auxdata1

type Fts5Auxiliary

type Fts5Auxiliary = TFts5Auxiliary

type Fts5Auxiliary1

type Fts5Auxiliary1 = TFts5Auxiliary1

type Fts5Bm25Data

type Fts5Bm25Data = TFts5Bm25Data

type Fts5Bm25Data1

type Fts5Bm25Data1 = TFts5Bm25Data1

type Fts5Buffer

type Fts5Buffer = TFts5Buffer

type Fts5Buffer1

type Fts5Buffer1 = TFts5Buffer1

type Fts5CResult

type Fts5CResult = TFts5CResult

type Fts5CResult1

type Fts5CResult1 = TFts5CResult1

type Fts5Colset

type Fts5Colset = TFts5Colset

type Fts5Colset1

type Fts5Colset1 = TFts5Colset1

type Fts5Config

type Fts5Config = TFts5Config

type Fts5Config1

type Fts5Config1 = TFts5Config1

type Fts5Cursor

type Fts5Cursor = TFts5Cursor

type Fts5Cursor1

type Fts5Cursor1 = TFts5Cursor1

type Fts5Data

type Fts5Data = TFts5Data

type Fts5Data1

type Fts5Data1 = TFts5Data1

type Fts5DlidxIter

type Fts5DlidxIter = TFts5DlidxIter

type Fts5DlidxIter1

type Fts5DlidxIter1 = TFts5DlidxIter1

type Fts5DlidxLvl

type Fts5DlidxLvl = TFts5DlidxLvl

type Fts5DlidxLvl1

type Fts5DlidxLvl1 = TFts5DlidxLvl1

type Fts5DlidxWriter

type Fts5DlidxWriter = TFts5DlidxWriter

type Fts5DlidxWriter1

type Fts5DlidxWriter1 = TFts5DlidxWriter1

type Fts5DoclistIter

type Fts5DoclistIter = TFts5DoclistIter

type Fts5DoclistIter1

type Fts5DoclistIter1 = TFts5DoclistIter1

type Fts5Enum

type Fts5Enum = TFts5Enum

type Fts5Enum1

type Fts5Enum1 = TFts5Enum1

type Fts5Expr

type Fts5Expr = TFts5Expr

type Fts5Expr1

type Fts5Expr1 = TFts5Expr1

type Fts5ExprCtx

type Fts5ExprCtx = TFts5ExprCtx

type Fts5ExprCtx1

type Fts5ExprCtx1 = TFts5ExprCtx1

type Fts5ExprNearset

type Fts5ExprNearset = TFts5ExprNearset

type Fts5ExprNearset1

type Fts5ExprNearset1 = TFts5ExprNearset1

type Fts5ExprNode

type Fts5ExprNode = TFts5ExprNode

type Fts5ExprNode1

type Fts5ExprNode1 = TFts5ExprNode1

type Fts5ExprPhrase

type Fts5ExprPhrase = TFts5ExprPhrase

type Fts5ExprPhrase1

type Fts5ExprPhrase1 = TFts5ExprPhrase1

type Fts5ExprTerm

type Fts5ExprTerm = TFts5ExprTerm

type Fts5ExprTerm1

type Fts5ExprTerm1 = TFts5ExprTerm1

type Fts5ExtensionApi

type Fts5ExtensionApi = TFts5ExtensionApi

type Fts5ExtensionApi1

type Fts5ExtensionApi1 = TFts5ExtensionApi1

type Fts5FlushCtx

type Fts5FlushCtx = TFts5FlushCtx

type Fts5FlushCtx1

type Fts5FlushCtx1 = TFts5FlushCtx1

type Fts5FullTable

type Fts5FullTable = TFts5FullTable

type Fts5FullTable1

type Fts5FullTable1 = TFts5FullTable1

type Fts5Global

type Fts5Global = TFts5Global

type Fts5Global1

type Fts5Global1 = TFts5Global1

type Fts5Hash

type Fts5Hash = TFts5Hash

type Fts5Hash1

type Fts5Hash1 = TFts5Hash1

type Fts5HashEntry

type Fts5HashEntry = TFts5HashEntry

type Fts5HashEntry1

type Fts5HashEntry1 = TFts5HashEntry1

type Fts5Index

type Fts5Index = TFts5Index

type Fts5Index1

type Fts5Index1 = TFts5Index1

type Fts5IndexIter

type Fts5IndexIter = TFts5IndexIter

type Fts5IndexIter1

type Fts5IndexIter1 = TFts5IndexIter1

type Fts5InsertCtx

type Fts5InsertCtx = TFts5InsertCtx

type Fts5InsertCtx1

type Fts5InsertCtx1 = TFts5InsertCtx1

type Fts5IntegrityCtx

type Fts5IntegrityCtx = TFts5IntegrityCtx

type Fts5IntegrityCtx1

type Fts5IntegrityCtx1 = TFts5IntegrityCtx1

type Fts5Iter

type Fts5Iter = TFts5Iter

type Fts5Iter1

type Fts5Iter1 = TFts5Iter1

type Fts5LookaheadReader

type Fts5LookaheadReader = TFts5LookaheadReader

type Fts5LookaheadReader1

type Fts5LookaheadReader1 = TFts5LookaheadReader1

type Fts5MatchPhrase

type Fts5MatchPhrase = TFts5MatchPhrase

type Fts5NearTrimmer

type Fts5NearTrimmer = TFts5NearTrimmer

type Fts5NearTrimmer1

type Fts5NearTrimmer1 = TFts5NearTrimmer1

type Fts5PageWriter

type Fts5PageWriter = TFts5PageWriter

type Fts5PageWriter1

type Fts5PageWriter1 = TFts5PageWriter1

type Fts5Parse

type Fts5Parse = TFts5Parse

type Fts5Parse1

type Fts5Parse1 = TFts5Parse1

type Fts5PhraseIter

type Fts5PhraseIter = TFts5PhraseIter

type Fts5PhraseIter1

type Fts5PhraseIter1 = TFts5PhraseIter1

type Fts5PoslistPopulator

type Fts5PoslistPopulator = TFts5PoslistPopulator

type Fts5PoslistPopulator1

type Fts5PoslistPopulator1 = TFts5PoslistPopulator1

type Fts5PoslistReader

type Fts5PoslistReader = TFts5PoslistReader

type Fts5PoslistReader1

type Fts5PoslistReader1 = TFts5PoslistReader1

type Fts5PoslistWriter

type Fts5PoslistWriter = TFts5PoslistWriter

type Fts5PoslistWriter1

type Fts5PoslistWriter1 = TFts5PoslistWriter1

type Fts5SFinder

type Fts5SFinder = TFts5SFinder

type Fts5SFinder1

type Fts5SFinder1 = TFts5SFinder1

type Fts5SegIter

type Fts5SegIter = TFts5SegIter

type Fts5SegIter1

type Fts5SegIter1 = TFts5SegIter1

type Fts5SegWriter

type Fts5SegWriter = TFts5SegWriter

type Fts5SegWriter1

type Fts5SegWriter1 = TFts5SegWriter1

type Fts5Sorter

type Fts5Sorter = TFts5Sorter

type Fts5Sorter1

type Fts5Sorter1 = TFts5Sorter1

type Fts5Storage

type Fts5Storage = TFts5Storage

type Fts5Storage1

type Fts5Storage1 = TFts5Storage1

type Fts5Structure

type Fts5Structure = TFts5Structure

type Fts5Structure1

type Fts5Structure1 = TFts5Structure1

type Fts5StructureLevel

type Fts5StructureLevel = TFts5StructureLevel

type Fts5StructureLevel1

type Fts5StructureLevel1 = TFts5StructureLevel1

type Fts5StructureSegment

type Fts5StructureSegment = TFts5StructureSegment

type Fts5StructureSegment1

type Fts5StructureSegment1 = TFts5StructureSegment1

type Fts5Table

type Fts5Table = TFts5Table

type Fts5Table1

type Fts5Table1 = TFts5Table1

type Fts5Termset

type Fts5Termset = TFts5Termset

type Fts5Termset1

type Fts5Termset1 = TFts5Termset1

type Fts5TermsetEntry

type Fts5TermsetEntry = TFts5TermsetEntry

type Fts5TermsetEntry1

type Fts5TermsetEntry1 = TFts5TermsetEntry1

type Fts5Token

type Fts5Token = TFts5Token

type Fts5Token1

type Fts5Token1 = TFts5Token1

type Fts5TokenDataIter

type Fts5TokenDataIter = TFts5TokenDataIter

type Fts5TokenDataIter1

type Fts5TokenDataIter1 = TFts5TokenDataIter1

type Fts5TokenDataMap

type Fts5TokenDataMap = TFts5TokenDataMap

type Fts5TokenDataMap1

type Fts5TokenDataMap1 = TFts5TokenDataMap1

type Fts5TokenizerModule

type Fts5TokenizerModule = TFts5TokenizerModule

type Fts5TokenizerModule1

type Fts5TokenizerModule1 = TFts5TokenizerModule1

type Fts5TombstoneArray

type Fts5TombstoneArray = TFts5TombstoneArray

type Fts5TombstoneArray1

type Fts5TombstoneArray1 = TFts5TombstoneArray1

type Fts5TransactionState

type Fts5TransactionState = TFts5TransactionState

type Fts5VocabCursor

type Fts5VocabCursor = TFts5VocabCursor

type Fts5VocabCursor1

type Fts5VocabCursor1 = TFts5VocabCursor1

type Fts5VocabTable

type Fts5VocabTable = TFts5VocabTable

type Fts5VocabTable1

type Fts5VocabTable1 = TFts5VocabTable1

type FuncDef

type FuncDef = TFuncDef

type FuncDef1

type FuncDef1 = TFuncDef1

type FuncDefHash

type FuncDefHash = TFuncDefHash

type FuncDefHash1

type FuncDefHash1 = TFuncDefHash1

type FuncDestructor

type FuncDestructor = TFuncDestructor

type FuncDestructor1

type FuncDestructor1 = TFuncDestructor1

type GeoBBox

type GeoBBox = TGeoBBox

type GeoBBox1

type GeoBBox1 = TGeoBBox1

type GeoCoord

type GeoCoord = TGeoCoord

type GeoEvent

type GeoEvent = TGeoEvent

type GeoEvent1

type GeoEvent1 = TGeoEvent1

type GeoOverlap

type GeoOverlap = TGeoOverlap

type GeoOverlap1

type GeoOverlap1 = TGeoOverlap1

type GeoParse

type GeoParse = TGeoParse

type GeoParse1

type GeoParse1 = TGeoParse1

type GeoPoly

type GeoPoly = TGeoPoly

type GeoPoly1

type GeoPoly1 = TGeoPoly1

type GeoSegment

type GeoSegment = TGeoSegment

type GeoSegment1

type GeoSegment1 = TGeoSegment1

type GroupConcatCtx

type GroupConcatCtx = TGroupConcatCtx

type Hash

type Hash = THash

type Hash1

type Hash1 = THash1

type HashElem

type HashElem = THashElem

type HashElem1

type HashElem1 = THashElem1

type HiddenIndexInfo

type HiddenIndexInfo = THiddenIndexInfo

type HiddenIndexInfo1

type HiddenIndexInfo1 = THiddenIndexInfo1

type HighlightContext

type HighlightContext = THighlightContext

type HighlightContext1

type HighlightContext1 = THighlightContext1

type IdList

type IdList = TIdList

type IdList1

type IdList1 = TIdList1

type IdList_item

type IdList_item = TIdList_item

type IdxCover

type IdxCover = TIdxCover

type InLoop

type InLoop = TInLoop

type IncrMerger

type IncrMerger = TIncrMerger

type IncrMerger1

type IncrMerger1 = TIncrMerger1

type Incrblob

type Incrblob = TIncrblob

type Incrblob1

type Incrblob1 = TIncrblob1

type Index

type Index = TIndex

type Index1

type Index1 = TIndex1

type IndexIterator

type IndexIterator = TIndexIterator

type IndexIterator1

type IndexIterator1 = TIndexIterator1

type IndexListTerm

type IndexListTerm = TIndexListTerm

type IndexListTerm1

type IndexListTerm1 = TIndexListTerm1

type IndexSample

type IndexSample = TIndexSample

type IndexSample1

type IndexSample1 = TIndexSample1

type IndexedExpr

type IndexedExpr = TIndexedExpr

type IndexedExpr1

type IndexedExpr1 = TIndexedExpr1

type InitData

type InitData = TInitData

type IntegrityCk

type IntegrityCk = TIntegrityCk

type IntegrityCk1

type IntegrityCk1 = TIntegrityCk1

type JsonCache

type JsonCache = TJsonCache

type JsonCache1

type JsonCache1 = TJsonCache1

type JsonEachConnection

type JsonEachConnection = TJsonEachConnection

type JsonEachConnection1

type JsonEachConnection1 = TJsonEachConnection1

type JsonEachCursor

type JsonEachCursor = TJsonEachCursor

type JsonEachCursor1

type JsonEachCursor1 = TJsonEachCursor1

type JsonParent

type JsonParent = TJsonParent

type JsonParent1

type JsonParent1 = TJsonParent1

type JsonParse

type JsonParse = TJsonParse

type JsonParse1

type JsonParse1 = TJsonParse1

type JsonPretty

type JsonPretty = TJsonPretty

type JsonPretty1

type JsonPretty1 = TJsonPretty1

type JsonString

type JsonString = TJsonString

type JsonString1

type JsonString1 = TJsonString1

type KeyInfo

type KeyInfo = TKeyInfo

type KeyInfo1

type KeyInfo1 = TKeyInfo1

type LastValueCtx

type LastValueCtx = TLastValueCtx

type LogEst

type LogEst = TLogEst

type Lookaside

type Lookaside = TLookaside

type Lookaside1

type Lookaside1 = TLookaside1

type LookasideSlot

type LookasideSlot = TLookasideSlot

type LookasideSlot1

type LookasideSlot1 = TLookasideSlot1

type Mem

type Mem = TMem

type Mem0Global

type Mem0Global = TMem0Global

type MemFS

type MemFS = TMemFS

type MemFile

type MemFile = TMemFile

type MemFile1

type MemFile1 = TMemFile1

type MemJournal

type MemJournal = TMemJournal

type MemJournal1

type MemJournal1 = TMemJournal1

type MemPage

type MemPage = TMemPage

type MemPage1

type MemPage1 = TMemPage1

type MemStore

type MemStore = TMemStore

type MemStore1

type MemStore1 = TMemStore1

type MemValue

type MemValue = TMemValue

type MemVfs

type MemVfs = TMemVfs

type MergeEngine

type MergeEngine = TMergeEngine

type MergeEngine1

type MergeEngine1 = TMergeEngine1

type Module

type Module = TModule

type Module1

type Module1 = TModule1

type NameContext

type NameContext = TNameContext

type NameContext1

type NameContext1 = TNameContext1

type NanInfName

type NanInfName = TNanInfName

type NthValueCtx

type NthValueCtx = TNthValueCtx

type NtileCtx

type NtileCtx = TNtileCtx

type OnOrUsing

type OnOrUsing = TOnOrUsing

type OnOrUsing1

type OnOrUsing1 = TOnOrUsing1

type Op

type Op = TOp

type PCache

type PCache = TPCache

type PCache1

type PCache1 = TPCache1

type PCache11

type PCache11 = TPCache11

type PCache2

type PCache2 = TPCache2

type PCacheGlobal

type PCacheGlobal = TPCacheGlobal

type PGroup

type PGroup = TPGroup

type PGroup1

type PGroup1 = TPGroup1

type Pager

type Pager = TPager

type Pager1

type Pager1 = TPager1

type PagerSavepoint

type PagerSavepoint = TPagerSavepoint

type PagerSavepoint1

type PagerSavepoint1 = TPagerSavepoint1

type Parse

type Parse = TParse

type Parse1

type Parse1 = TParse1

type ParseCleanup

type ParseCleanup = TParseCleanup

type ParseCleanup1

type ParseCleanup1 = TParseCleanup1

type PgFreeslot

type PgFreeslot = TPgFreeslot

type PgFreeslot1

type PgFreeslot1 = TPgFreeslot1

type PgHdr

type PgHdr = TPgHdr

type PgHdr1

type PgHdr1 = TPgHdr1

type PgHdr11

type PgHdr11 = TPgHdr11

type PgHdr2

type PgHdr2 = TPgHdr2

type Pgno

type Pgno = TPgno

type PmaReader

type PmaReader = TPmaReader

type PmaReader1

type PmaReader1 = TPmaReader1

type PmaWriter

type PmaWriter = TPmaWriter

type PmaWriter1

type PmaWriter1 = TPmaWriter1

type PorterContext

type PorterContext = TPorterContext

type PorterContext1

type PorterContext1 = TPorterContext1

type PorterRule

type PorterRule = TPorterRule

type PorterRule1

type PorterRule1 = TPorterRule1

type PorterTokenizer

type PorterTokenizer = TPorterTokenizer

type PorterTokenizer1

type PorterTokenizer1 = TPorterTokenizer1

type PoslistCallbackCtx

type PoslistCallbackCtx = TPoslistCallbackCtx

type PoslistCallbackCtx1

type PoslistCallbackCtx1 = TPoslistCallbackCtx1

type PoslistOffsetsCtx

type PoslistOffsetsCtx = TPoslistOffsetsCtx

type PoslistOffsetsCtx1

type PoslistOffsetsCtx1 = TPoslistOffsetsCtx1

type PragmaName

type PragmaName = TPragmaName

type PragmaVtab

type PragmaVtab = TPragmaVtab

type PragmaVtab1

type PragmaVtab1 = TPragmaVtab1

type PragmaVtabCursor

type PragmaVtabCursor = TPragmaVtabCursor

type PragmaVtabCursor1

type PragmaVtabCursor1 = TPragmaVtabCursor1

type PreUpdate

type PreUpdate = TPreUpdate

type PreUpdate1

type PreUpdate1 = TPreUpdate1

type PrefixMerger

type PrefixMerger = TPrefixMerger

type PrefixMerger1

type PrefixMerger1 = TPrefixMerger1

type PrintfArguments

type PrintfArguments = TPrintfArguments

type PrintfArguments1

type PrintfArguments1 = TPrintfArguments1

type RCStr

type RCStr = TRCStr

type RCStr1

type RCStr1 = TRCStr1

type RbuFrame

type RbuFrame = TRbuFrame

type RbuFrame1

type RbuFrame1 = TRbuFrame1

type RbuObjIter

type RbuObjIter = TRbuObjIter

type RbuObjIter1

type RbuObjIter1 = TRbuObjIter1

type RbuSpan

type RbuSpan = TRbuSpan

type RbuSpan1

type RbuSpan1 = TRbuSpan1

type RbuState

type RbuState = TRbuState

type RbuState1

type RbuState1 = TRbuState1

type RbuUpdateStmt

type RbuUpdateStmt = TRbuUpdateStmt

type RbuUpdateStmt1

type RbuUpdateStmt1 = TRbuUpdateStmt1

type RecordCompare

type RecordCompare = TRecordCompare

type RefSrcList

type RefSrcList = TRefSrcList

type RenameCtx

type RenameCtx = TRenameCtx

type RenameCtx1

type RenameCtx1 = TRenameCtx1

type RenameToken

type RenameToken = TRenameToken

type RenameToken1

type RenameToken1 = TRenameToken1

type Returning

type Returning = TReturning

type Returning1

type Returning1 = TReturning1

type ReusableSpace

type ReusableSpace = TReusableSpace

type RowLoadInfo

type RowLoadInfo = TRowLoadInfo

type RowLoadInfo1

type RowLoadInfo1 = TRowLoadInfo1

type RowSet

type RowSet = TRowSet

type RowSet1

type RowSet1 = TRowSet1

type RowSetChunk

type RowSetChunk = TRowSetChunk

type RowSetEntry

type RowSetEntry = TRowSetEntry

type Rtree

type Rtree = TRtree

type Rtree1

type Rtree1 = TRtree1

type RtreeCell

type RtreeCell = TRtreeCell

type RtreeCell1

type RtreeCell1 = TRtreeCell1

type RtreeCheck

type RtreeCheck = TRtreeCheck

type RtreeCheck1

type RtreeCheck1 = TRtreeCheck1

type RtreeConstraint

type RtreeConstraint = TRtreeConstraint

type RtreeConstraint1

type RtreeConstraint1 = TRtreeConstraint1

type RtreeCoord

type RtreeCoord = TRtreeCoord

type RtreeCoord1

type RtreeCoord1 = TRtreeCoord1

type RtreeCursor

type RtreeCursor = TRtreeCursor

type RtreeCursor1

type RtreeCursor1 = TRtreeCursor1

type RtreeDValue

type RtreeDValue = TRtreeDValue

type RtreeGeomCallback

type RtreeGeomCallback = TRtreeGeomCallback

type RtreeGeomCallback1

type RtreeGeomCallback1 = TRtreeGeomCallback1

type RtreeMatchArg

type RtreeMatchArg = TRtreeMatchArg

type RtreeMatchArg1

type RtreeMatchArg1 = TRtreeMatchArg1

type RtreeNode

type RtreeNode = TRtreeNode

type RtreeNode1

type RtreeNode1 = TRtreeNode1

type RtreeSearchPoint

type RtreeSearchPoint = TRtreeSearchPoint

type RtreeSearchPoint1

type RtreeSearchPoint1 = TRtreeSearchPoint1

type RtreeValue

type RtreeValue = TRtreeValue

type SQLiteThread

type SQLiteThread = TSQLiteThread

type SQLiteThread1

type SQLiteThread1 = TSQLiteThread1

type Savepoint

type Savepoint = TSavepoint

type Savepoint1

type Savepoint1 = TSavepoint1

type ScanStatus

type ScanStatus = TScanStatus

type ScanStatus1

type ScanStatus1 = TScanStatus1

type Schema

type Schema = TSchema

type Schema1

type Schema1 = TSchema1

type Select

type Select = TSelect

type Select1

type Select1 = TSelect1

type SelectDest

type SelectDest = TSelectDest

type SelectDest1

type SelectDest1 = TSelectDest1

type SessionApplyCtx

type SessionApplyCtx = TSessionApplyCtx

type SessionApplyCtx1

type SessionApplyCtx1 = TSessionApplyCtx1

type SessionBuffer

type SessionBuffer = TSessionBuffer

type SessionBuffer1

type SessionBuffer1 = TSessionBuffer1

type SessionChange

type SessionChange = TSessionChange

type SessionChange1

type SessionChange1 = TSessionChange1

type SessionDiffCtx

type SessionDiffCtx = TSessionDiffCtx

type SessionDiffCtx1

type SessionDiffCtx1 = TSessionDiffCtx1

type SessionHook

type SessionHook = TSessionHook

type SessionHook1

type SessionHook1 = TSessionHook1

type SessionInput

type SessionInput = TSessionInput

type SessionInput1

type SessionInput1 = TSessionInput1

type SessionStat1Ctx

type SessionStat1Ctx = TSessionStat1Ctx

type SessionStat1Ctx1

type SessionStat1Ctx1 = TSessionStat1Ctx1

type SessionTable

type SessionTable = TSessionTable

type SessionTable1

type SessionTable1 = TSessionTable1

type SessionUpdate

type SessionUpdate = TSessionUpdate

type SessionUpdate1

type SessionUpdate1 = TSessionUpdate1

type SortCtx

type SortCtx = TSortCtx

type SortCtx1

type SortCtx1 = TSortCtx1

type SortSubtask

type SortSubtask = TSortSubtask

type SortSubtask1

type SortSubtask1 = TSortSubtask1

type SorterCompare

type SorterCompare = TSorterCompare

type SorterFile

type SorterFile = TSorterFile

type SorterFile1

type SorterFile1 = TSorterFile1

type SorterList

type SorterList = TSorterList

type SorterList1

type SorterList1 = TSorterList1

type SorterRecord

type SorterRecord = TSorterRecord

type SorterRecord1

type SorterRecord1 = TSorterRecord1

type Sqlite3Config

type Sqlite3Config = TSqlite3Config

type Sqlite3_index_constraint

type Sqlite3_index_constraint = sqlite3_index_constraint

type Sqlite3_index_constraint_usage

type Sqlite3_index_constraint_usage = sqlite3_index_constraint_usage

type Sqlite3_index_info

type Sqlite3_index_info = sqlite3_index_info

type Sqlite3_index_orderby

type Sqlite3_index_orderby = sqlite3_index_orderby

type Sqlite3_int64

type Sqlite3_int64 = sqlite3_int64

type Sqlite3_module

type Sqlite3_module = sqlite3_module

type Sqlite3_mutex_methods

type Sqlite3_mutex_methods = sqlite3_mutex_methods

type Sqlite3_value

type Sqlite3_value = sqlite3_value

type Sqlite3_vtab

type Sqlite3_vtab = sqlite3_vtab

type Sqlite3_vtab_cursor

type Sqlite3_vtab_cursor = sqlite3_vtab_cursor

type SrcItem

type SrcItem = TSrcItem

type SrcItem1

type SrcItem1 = TSrcItem1

type SrcList

type SrcList = TSrcList

type SrcList1

type SrcList1 = TSrcList1

type StatAccum

type StatAccum = TStatAccum

type StatAccum1

type StatAccum1 = TStatAccum1

type StatCell

type StatCell = TStatCell

type StatCell1

type StatCell1 = TStatCell1

type StatCursor

type StatCursor = TStatCursor

type StatCursor1

type StatCursor1 = TStatCursor1

type StatPage

type StatPage = TStatPage

type StatPage1

type StatPage1 = TStatPage1

type StatSample

type StatSample = TStatSample

type StatSample1

type StatSample1 = TStatSample1

type StatTable

type StatTable = TStatTable

type StatTable1

type StatTable1 = TStatTable1

type StrAccum

type StrAccum = TStrAccum

type SubProgram

type SubProgram = TSubProgram

type SubProgram1

type SubProgram1 = TSubProgram1

type SubstContext

type SubstContext = TSubstContext

type SumCtx

type SumCtx = TSumCtx

type SumCtx1

type SumCtx1 = TSumCtx1

type TAggInfo

type TAggInfo = struct {
	FdirectMode     Tu8
	FuseSortingIdx  Tu8
	FnSortingColumn Tu16
	FsortingIdx     int32
	FsortingIdxPTab int32
	FiFirstReg      int32
	FpGroupBy       uintptr
	FaCol           uintptr
	FnColumn        int32
	FnAccumulator   int32
	FaFunc          uintptr
	FnFunc          int32
	FselId          Tu32
}

C documentation

/*
** Forward references to structures
*/

type TAggInfo1

type TAggInfo1 = struct {
	FdirectMode     Tu8
	FuseSortingIdx  Tu8
	FnSortingColumn Tu16
	FsortingIdx     int32
	FsortingIdxPTab int32
	FiFirstReg      int32
	FpGroupBy       uintptr
	FaCol           uintptr
	FnColumn        int32
	FnAccumulator   int32
	FaFunc          uintptr
	FnFunc          int32
	FselId          Tu32
}

** An instance of this structure contains information needed to generate ** code for a SELECT that contains aggregate functions. ** ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a ** pointer to this structure. The Expr.iAgg field is the index in ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate ** code for that node. ** ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the ** original Select structure that describes the SELECT statement. These ** fields do not need to be freed when deallocating the AggInfo structure.

type TAggInfo_col

type TAggInfo_col = struct {
	FpTab          uintptr
	FpCExpr        uintptr
	FiTable        int32
	FiColumn       Ti16
	FiSorterColumn Ti16
}

type TAggInfo_func

type TAggInfo_func = struct {
	FpFExpr      uintptr
	FpFunc       uintptr
	FiDistinct   int32
	FiDistAddr   int32
	FiOBTab      int32
	FbOBPayload  Tu8
	FbOBUnique   Tu8
	FbUseSubtype Tu8
}

type TAsciiTokenizer

type TAsciiTokenizer = struct {
	FaTokenChar [128]uint8
}

type TAsciiTokenizer1

type TAsciiTokenizer1 = struct {
	FaTokenChar [128]uint8
}

type TAuthContext

type TAuthContext = struct {
	FzAuthContext uintptr
	FpParse       uintptr
}

type TAuthContext1

type TAuthContext1 = struct {
	FzAuthContext uintptr
	FpParse       uintptr
}

** An instance of the following structure can be declared on a stack and used ** to save the Parse.zAuthContext value so that it can be restored later.

type TAutoincInfo

type TAutoincInfo = struct {
	FpNext  uintptr
	FpTab   uintptr
	FiDb    int32
	FregCtr int32
}

type TAutoincInfo1

type TAutoincInfo1 = struct {
	FpNext  uintptr
	FpTab   uintptr
	FiDb    int32
	FregCtr int32
}

** During code generation of statements that do inserts into AUTOINCREMENT ** tables, the following information is attached to the Table.u.autoInc.p ** pointer of each autoincrement table to record some side information that ** the code generator needs. We have to keep per-table autoincrement ** information in case inserts are done within triggers. Triggers do not ** normally coordinate their activities, but we do need to coordinate the ** loading and saving of autoincrement information.

type TAuxData

type TAuxData = struct {
	FiAuxOp     int32
	FiAuxArg    int32
	FpAux       uintptr
	FxDeleteAux uintptr
	FpNextAux   uintptr
}

C documentation

/* Elements of the linked list at Vdbe.pAuxData */

type TAuxData1

type TAuxData1 = struct {
	FiAuxOp     int32
	FiAuxArg    int32
	FpAux       uintptr
	FxDeleteAux uintptr
	FpNextAux   uintptr
}

** Each auxiliary data pointer stored by a user defined function ** implementation calling sqlite3_set_auxdata() is stored in an instance ** of this structure. All such structures associated with a single VM ** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed ** when the VM is halted (if not before).

type TBenignMallocHooks

type TBenignMallocHooks = struct {
	FxBenignBegin uintptr
	FxBenignEnd   uintptr
}

C documentation

/*
** Global variables.
*/

type TBenignMallocHooks1

type TBenignMallocHooks1 = struct {
	FxBenignBegin uintptr
	FxBenignEnd   uintptr
}

type TBitmask

type TBitmask = uint64

C documentation

/*
** The bitmask datatype defined below is used for various optimizations.
**
** Changing this from a 64-bit to a 32-bit type limits the number of
** tables in a join to 32 instead of 64.  But it also reduces the size
** of the library by 738 bytes on ix86.
*/

type TBitvec

type TBitvec = struct {
	FiSize    Tu32
	FnSet     Tu32
	FiDivisor Tu32
	Fu        struct {
		FaHash   [0][124]Tu32
		FapSub   [0][62]uintptr
		FaBitmap [496]Tu8
	}
}

type TBitvec1

type TBitvec1 = struct {
	FiSize    Tu32
	FnSet     Tu32
	FiDivisor Tu32
	Fu        struct {
		FaHash   [0][124]Tu32
		FapSub   [0][62]uintptr
		FaBitmap [496]Tu8
	}
}

** A bitmap is an instance of the following structure. ** ** This bitmap records the existence of zero or more bits ** with values between 1 and iSize, inclusive. ** ** There are three possible representations of the bitmap. ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight ** bitmap. The least significant bit is bit 1. ** ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is ** a hash table that will hold up to BITVEC_MXHASH distinct values. ** ** Otherwise, the value i is redirected into one of BITVEC_NPTR ** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap ** handles up to iDivisor separate values of i. apSub[0] holds ** values between 1 and iDivisor. apSub[1] holds values between ** iDivisor+1 and 2*iDivisor. apSub[N] holds values between ** N*iDivisor+1 and (N+1)*iDivisor. Each subbitmap is normalized ** to hold deal with values between 1 and iDivisor.

type TBool

type TBool = uint32

C documentation

/*
** Boolean values
*/

type TBtCursor

type TBtCursor = struct {
	FeState        Tu8
	FcurFlags      Tu8
	FcurPagerFlags Tu8
	Fhints         Tu8
	FskipNext      int32
	FpBtree        uintptr
	FaOverflow     uintptr
	FpKey          uintptr
	FpBt           uintptr
	FpNext         uintptr
	Finfo          TCellInfo
	FnKey          Ti64
	FpgnoRoot      TPgno
	FiPage         Ti8
	FcurIntKey     Tu8
	Fix            Tu16
	FaiIdx         [19]Tu16
	FpKeyInfo      uintptr
	FpPage         uintptr
	FapPage        [19]uintptr
}

type TBtCursor1

type TBtCursor1 = struct {
	FeState        Tu8
	FcurFlags      Tu8
	FcurPagerFlags Tu8
	Fhints         Tu8
	FskipNext      int32
	FpBtree        uintptr
	FaOverflow     uintptr
	FpKey          uintptr
	FpBt           uintptr
	FpNext         uintptr
	Finfo          TCellInfo
	FnKey          Ti64
	FpgnoRoot      TPgno
	FiPage         Ti8
	FcurIntKey     Tu8
	Fix            Tu16
	FaiIdx         [19]Tu16
	FpKeyInfo      uintptr
	FpPage         uintptr
	FapPage        [19]uintptr
}

** A cursor is a pointer to a particular entry within a particular ** b-tree within a database file. ** ** The entry is identified by its MemPage and the index in ** MemPage.aCell[] of the entry. ** ** A single database file can be shared by two more database connections, ** but cursors cannot be shared. Each cursor is associated with a ** particular database connection identified BtCursor.pBtree.db. ** ** Fields in this structure are accessed under the BtShared.mutex ** found at self->pBt->mutex. ** ** skipNext meaning: ** The meaning of skipNext depends on the value of eState: ** ** eState Meaning of skipNext ** VALID skipNext is meaningless and is ignored ** INVALID skipNext is meaningless and is ignored ** SKIPNEXT sqlite3BtreeNext() is a no-op if skipNext>0 and ** sqlite3BtreePrevious() is no-op if skipNext<0. ** REQUIRESEEK restoreCursorPosition() restores the cursor to ** eState=SKIPNEXT if skipNext!=0 ** FAULT skipNext holds the cursor fault error code.

type TBtLock

type TBtLock = struct {
	FpBtree uintptr
	FiTable TPgno
	FeLock  Tu8
	FpNext  uintptr
}

type TBtLock1

type TBtLock1 = struct {
	FpBtree uintptr
	FiTable TPgno
	FeLock  Tu8
	FpNext  uintptr
}

** A linked list of the following structures is stored at BtShared.pLock. ** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor ** is opened on the table with root page BtShared.iTable. Locks are removed ** from this list when a transaction is committed or rolled back, or when ** a btree handle is closed.

type TBtShared

type TBtShared = struct {
	FpPager          uintptr
	Fdb              uintptr
	FpCursor         uintptr
	FpPage1          uintptr
	FopenFlags       Tu8
	FautoVacuum      Tu8
	FincrVacuum      Tu8
	FbDoTruncate     Tu8
	FinTransaction   Tu8
	Fmax1bytePayload Tu8
	FnReserveWanted  Tu8
	FbtsFlags        Tu16
	FmaxLocal        Tu16
	FminLocal        Tu16
	FmaxLeaf         Tu16
	FminLeaf         Tu16
	FpageSize        Tu32
	FusableSize      Tu32
	FnTransaction    int32
	FnPage           Tu32
	FpSchema         uintptr
	FxFreeSchema     uintptr
	Fmutex           uintptr
	FpHasContent     uintptr
	FnRef            int32
	FpNext           uintptr
	FpLock           uintptr
	FpWriter         uintptr
	FpTmpSpace       uintptr
	FnPreformatSize  int32
}

type TBtShared1

type TBtShared1 = struct {
	FpPager          uintptr
	Fdb              uintptr
	FpCursor         uintptr
	FpPage1          uintptr
	FopenFlags       Tu8
	FautoVacuum      Tu8
	FincrVacuum      Tu8
	FbDoTruncate     Tu8
	FinTransaction   Tu8
	Fmax1bytePayload Tu8
	FnReserveWanted  Tu8
	FbtsFlags        Tu16
	FmaxLocal        Tu16
	FminLocal        Tu16
	FmaxLeaf         Tu16
	FminLeaf         Tu16
	FpageSize        Tu32
	FusableSize      Tu32
	FnTransaction    int32
	FnPage           Tu32
	FpSchema         uintptr
	FxFreeSchema     uintptr
	Fmutex           uintptr
	FpHasContent     uintptr
	FnRef            int32
	FpNext           uintptr
	FpLock           uintptr
	FpWriter         uintptr
	FpTmpSpace       uintptr
	FnPreformatSize  int32
}

** An instance of this object represents a single database file. ** ** A single database file can be in use at the same time by two ** or more database connections. When two or more connections are ** sharing the same database file, each connection has it own ** private Btree object for the file and each of those Btrees points ** to this one BtShared object. BtShared.nRef is the number of ** connections currently sharing this database file. ** ** Fields in this structure are accessed under the BtShared.mutex ** mutex, except for nRef and pNext which are accessed under the ** global SQLITE_MUTEX_STATIC_MAIN mutex. The pPager field ** may not be modified once it is initially set as long as nRef>0. ** The pSchema field may be set once under BtShared.mutex and ** thereafter is unchanged as long as nRef>0. ** ** isPending: ** ** If a BtShared client fails to obtain a write-lock on a database ** table (because there exists one or more read-locks on the table), ** the shared-cache enters 'pending-lock' state and isPending is ** set to true. ** ** The shared-cache leaves the 'pending lock' state when either of ** the following occur: ** ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR ** 2) The number of locks held by other connections drops to zero. ** ** while in the 'pending-lock' state, no connection may start a new ** transaction. ** ** This feature is included to help prevent writer-starvation.

type TBtree

type TBtree = struct {
	Fdb             uintptr
	FpBt            uintptr
	FinTrans        Tu8
	Fsharable       Tu8
	Flocked         Tu8
	FhasIncrblobCur Tu8
	FwantToLock     int32
	FnBackup        int32
	FiBDataVersion  Tu32
	FpNext          uintptr
	FpPrev          uintptr
	Flock           TBtLock
}

C documentation

/*
** Forward declarations of structure
*/

type TBtree1

type TBtree1 = struct {
	Fdb             uintptr
	FpBt            uintptr
	FinTrans        Tu8
	Fsharable       Tu8
	Flocked         Tu8
	FhasIncrblobCur Tu8
	FwantToLock     int32
	FnBackup        int32
	FiBDataVersion  Tu32
	FpNext          uintptr
	FpPrev          uintptr
	Flock           TBtLock
}

A Btree handle

** ** A database connection contains a pointer to an instance of ** this object for every database file that it has open. This structure ** is opaque to the database connection. The database connection cannot ** see the internals of this structure and only deals with pointers to ** this structure. ** ** For some database files, the same underlying database cache might be ** shared between multiple connections. In that case, each connection ** has it own instance of this object. But each instance of this object ** points to the same BtShared object. The database cache and the ** schema associated with the database file are all contained within ** the BtShared object. ** ** All fields in this structure are accessed under sqlite3.mutex. ** The pBt pointer itself may not be changed while there exists cursors ** in the referenced BtShared that point back to this Btree since those ** cursors have to go through this Btree to find their BtShared and ** they often do so without holding sqlite3.mutex.

type TBtreePayload

type TBtreePayload = struct {
	FpKey  uintptr
	FnKey  Tsqlite3_int64
	FpData uintptr
	FaMem  uintptr
	FnMem  Tu16
	FnData int32
	FnZero int32
}

type TBtreePayload1

type TBtreePayload1 = struct {
	FpKey  uintptr
	FnKey  Tsqlite3_int64
	FpData uintptr
	FaMem  uintptr
	FnMem  Tu16
	FnData int32
	FnZero int32
}

An instance of the BtreePayload object describes the content of a single

** entry in either an index or table btree. ** ** Index btrees (used for indexes and also WITHOUT ROWID tables) contain ** an arbitrary key and no data. These btrees have pKey,nKey set to the ** key and the pData,nData,nZero fields are uninitialized. The aMem,nMem ** fields give an array of Mem objects that are a decomposition of the key. ** The nMem field might be zero, indicating that no decomposition is available. ** ** Table btrees (used for rowid tables) contain an integer rowid used as ** the key and passed in the nKey field. The pKey field is zero. ** pData,nData hold the content of the new entry. nZero extra zero bytes ** are appended to the end of the content when constructing the entry. ** The aMem,nMem fields are uninitialized for table btrees. ** ** Field usage summary: ** ** Table BTrees Index Btrees ** ** pKey always NULL encoded key ** nKey the ROWID length of pKey ** pData data not used ** aMem not used decomposed key value ** nMem not used entries in aMem ** nData length of pData not used ** nZero extra zeros after pData not used ** ** This object is used to pass information into sqlite3BtreeInsert(). The ** same information used to be passed as five separate parameters. But placing ** the information into this object helps to keep the interface more ** organized and understandable, and it also helps the resulting code to ** run a little faster by using fewer registers for parameter passing.

type TBusyHandler

type TBusyHandler = struct {
	FxBusyHandler uintptr
	FpBusyArg     uintptr
	FnBusy        int32
}

C documentation

/*
** An instance of the following structure is used to store the busy-handler
** callback for a given sqlite handle.
**
** The sqlite.busyHandler member of the sqlite struct contains the busy
** callback for the database handle. Each pager opened via the sqlite
** handle is passed a pointer to sqlite.busyHandler. The busy-handler
** callback is currently invoked only from within pager.c.
*/

type TBusyHandler1

type TBusyHandler1 = struct {
	FxBusyHandler uintptr
	FpBusyArg     uintptr
	FnBusy        int32
}

type TCInstIter

type TCInstIter = struct {
	FpApi   uintptr
	FpFts   uintptr
	FiCol   int32
	FiInst  int32
	FnInst  int32
	FiStart int32
	FiEnd   int32
}

C documentation

/*
** Object used to iterate through all "coalesced phrase instances" in
** a single column of the current row. If the phrase instances in the
** column being considered do not overlap, this object simply iterates
** through them. Or, if they do overlap (share one or more tokens in
** common), each set of overlapping instances is treated as a single
** match. See documentation for the highlight() auxiliary function for
** details.
**
** Usage is:
**
**   for(rc = fts5CInstIterNext(pApi, pFts, iCol, &iter);
**      (rc==SQLITE_OK && 0==fts5CInstIterEof(&iter);
**      rc = fts5CInstIterNext(&iter)
**   ){
**     printf("instance starts at %d, ends at %d\n", iter.iStart, iter.iEnd);
**   }
**
*/

type TCInstIter1

type TCInstIter1 = struct {
	FpApi   uintptr
	FpFts   uintptr
	FiCol   int32
	FiInst  int32
	FnInst  int32
	FiStart int32
	FiEnd   int32
}

type TCallCount

type TCallCount = struct {
	FnValue Ti64
	FnStep  Ti64
	FnTotal Ti64
}

** Context object type used by rank(), dense_rank(), percent_rank() and ** cume_dist().

type TCellArray

type TCellArray = struct {
	FnCell  int32
	FpRef   uintptr
	FapCell uintptr
	FszCell uintptr
	FapEnd  [6]uintptr
	FixNx   [6]int32
}

C documentation

/*
** A CellArray object contains a cache of pointers and sizes for a
** consecutive sequence of cells that might be held on multiple pages.
**
** The cells in this array are the divider cell or cells from the pParent
** page plus up to three child pages.  There are a total of nCell cells.
**
** pRef is a pointer to one of the pages that contributes cells.  This is
** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
** which should be common to all pages that contribute cells to this array.
**
** apCell[] and szCell[] hold, respectively, pointers to the start of each
** cell and the size of each cell.  Some of the apCell[] pointers might refer
** to overflow cells.  In other words, some apCel[] pointers might not point
** to content area of the pages.
**
** A szCell[] of zero means the size of that cell has not yet been computed.
**
** The cells come from as many as four different pages:
**
**             -----------
**             | Parent  |
**             -----------
**            /     |     **           /      |      **  ---------   ---------   ---------
**  |Child-1|   |Child-2|   |Child-3|
**  ---------   ---------   ---------
**
** The order of cells is in the array is for an index btree is:
**
**       1.  All cells from Child-1 in order
**       2.  The first divider cell from Parent
**       3.  All cells from Child-2 in order
**       4.  The second divider cell from Parent
**       5.  All cells from Child-3 in order
**
** For a table-btree (with rowids) the items 2 and 4 are empty because
** content exists only in leaves and there are no divider cells.
**
** For an index btree, the apEnd[] array holds pointer to the end of page
** for Child-1, the Parent, Child-2, the Parent (again), and Child-3,
** respectively. The ixNx[] array holds the number of cells contained in
** each of these 5 stages, and all stages to the left.  Hence:
**
**    ixNx[0] = Number of cells in Child-1.
**    ixNx[1] = Number of cells in Child-1 plus 1 for first divider.
**    ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider.
**    ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells
**    ixNx[4] = Total number of cells.
**
** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2]
** are used and they point to the leaf pages only, and the ixNx value are:
**
**    ixNx[0] = Number of cells in Child-1.
**    ixNx[1] = Number of cells in Child-1 and Child-2.
**    ixNx[2] = Total number of cells.
**
** Sometimes when deleting, a child page can have zero cells.  In those
** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[]
** entries, shift down.  The end result is that each ixNx[] entry should
** be larger than the previous
*/

type TCellArray1

type TCellArray1 = struct {
	FnCell  int32
	FpRef   uintptr
	FapCell uintptr
	FszCell uintptr
	FapEnd  [6]uintptr
	FixNx   [6]int32
}

type TCellInfo

type TCellInfo = struct {
	FnKey     Ti64
	FpPayload uintptr
	FnPayload Tu32
	FnLocal   Tu16
	FnSize    Tu16
}

type TCellInfo1

type TCellInfo1 = struct {
	FnKey     Ti64
	FpPayload uintptr
	FnPayload Tu32
	FnLocal   Tu16
	FnSize    Tu16
}

** An instance of the following structure is used to hold information ** about a cell. The parseCellPtr() function fills in this structure ** based on information extract from the raw disk page.

type TCollSeq

type TCollSeq = struct {
	FzName uintptr
	Fenc   Tu8
	FpUser uintptr
	FxCmp  uintptr
	FxDel  uintptr
}

type TCollSeq1

type TCollSeq1 = struct {
	FzName uintptr
	Fenc   Tu8
	FpUser uintptr
	FxCmp  uintptr
	FxDel  uintptr
}

** A "Collating Sequence" is defined by an instance of the following ** structure. Conceptually, a collating sequence consists of a name and ** a comparison routine that defines the order of that sequence. ** ** If CollSeq.xCmp is NULL, it means that the ** collating sequence is undefined. Indices built on an undefined ** collating sequence may not be read or written.

type TColumn

type TColumn = struct {
	FzCnName  uintptr
	F__ccgo8  uint8
	Faffinity int8
	FszEst    Tu8
	FhName    Tu8
	FiDflt    Tu16
	FcolFlags Tu16
}

type TColumn1

type TColumn1 = struct {
	FzCnName  uintptr
	F__ccgo8  uint8
	Faffinity int8
	FszEst    Tu8
	FhName    Tu8
	FiDflt    Tu16
	FcolFlags Tu16
}

** Information about each column of an SQL table is held in an instance ** of the Column structure, in the Table.aCol[] array. ** ** Definitions: ** ** "table column index" This is the index of the column in the ** Table.aCol[] array, and also the index of ** the column in the original CREATE TABLE stmt. ** ** "storage column index" This is the index of the column in the ** record BLOB generated by the OP_MakeRecord ** opcode. The storage column index is less than ** or equal to the table column index. It is ** equal if and only if there are no VIRTUAL ** columns to the left. ** ** Notes on zCnName: ** The zCnName field stores the name of the column, the datatype of the ** column, and the collating sequence for the column, in that order, all in ** a single allocation. Each string is 0x00 terminated. The datatype ** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the ** collating sequence name is only included if the COLFLAG_HASCOLL bit is ** set.

type TCountCtx

type TCountCtx = struct {
	Fn Ti64
}

C documentation

/*
** The following structure keeps track of state information for the
** count() aggregate function.
*/

type TCountCtx1

type TCountCtx1 = struct {
	Fn Ti64
}

type TCoveringIndexCheck

type TCoveringIndexCheck = struct {
	FpIdx    uintptr
	FiTabCur int32
	FbExpr   Tu8
	FbUnidx  Tu8
}

C documentation

/*
** Structure passed to the whereIsCoveringIndex Walker callback.
*/

type TCoveringIndexCheck1

type TCoveringIndexCheck1 = struct {
	FpIdx    uintptr
	FiTabCur int32
	FbExpr   Tu8
	FbUnidx  Tu8
}

type TCte

type TCte = struct {
	FzName   uintptr
	FpCols   uintptr
	FpSelect uintptr
	FzCteErr uintptr
	FpUse    uintptr
	FeM10d   Tu8
}

type TCte1

type TCte1 = struct {
	FzName   uintptr
	FpCols   uintptr
	FpSelect uintptr
	FzCteErr uintptr
	FpUse    uintptr
	FeM10d   Tu8
}

** A single common table expression

type TCteUse

type TCteUse = struct {
	FnUse    int32
	FaddrM9e int32
	FregRtn  int32
	FiCur    int32
	FnRowEst TLogEst
	FeM10d   Tu8
}

type TCteUse1

type TCteUse1 = struct {
	FnUse    int32
	FaddrM9e int32
	FregRtn  int32
	FiCur    int32
	FnRowEst TLogEst
	FeM10d   Tu8
}

** The Cte object is not guaranteed to persist for the entire duration ** of code generation. (The query flattener or other parser tree ** edits might delete it.) The following object records information ** about each Common Table Expression that must be preserved for the ** duration of the parse. ** ** The CteUse objects are freed using sqlite3ParserAddCleanup() rather ** than sqlite3SelectDelete(), which is what enables them to persist ** until the end of code generation.

type TDateTime

type TDateTime = struct {
	FiJD      Tsqlite3_int64
	FY        int32
	FM        int32
	FD        int32
	Fh        int32
	Fm        int32
	Ftz       int32
	Fs        float64
	FvalidJD  int8
	FvalidYMD int8
	FvalidHMS int8
	FnFloor   int8
	F__ccgo44 uint8
}

C documentation

/*
** A structure for holding a single date and time.
*/

type TDateTime1

type TDateTime1 = struct {
	FiJD      Tsqlite3_int64
	FY        int32
	FM        int32
	FD        int32
	Fh        int32
	Fm        int32
	Ftz       int32
	Fs        float64
	FvalidJD  int8
	FvalidYMD int8
	FvalidHMS int8
	FnFloor   int8
	F__ccgo44 uint8
}

type TDb

type TDb = struct {
	FzDbSName     uintptr
	FpBt          uintptr
	Fsafety_level Tu8
	FbSyncSet     Tu8
	FpSchema      uintptr
}

type TDb1

type TDb1 = struct {
	FzDbSName     uintptr
	FpBt          uintptr
	Fsafety_level Tu8
	FbSyncSet     Tu8
	FpSchema      uintptr
}

** Each database file to be accessed by the system is an instance ** of the following structure. There are normally two of these structures ** in the sqlite.aDb[] array. aDb[0] is the main database file and ** aDb[1] is the database file used to hold temporary tables. Additional ** databases may be attached.

type TDbClientData

type TDbClientData = struct {
	FpNext       uintptr
	FpData       uintptr
	FxDestructor uintptr
	FzName       [1]int8
}

type TDbClientData1

type TDbClientData1 = struct {
	FpNext       uintptr
	FpData       uintptr
	FxDestructor uintptr
	FzName       [1]int8
}

Client data associated with sqlite3_set_clientdata() and

** sqlite3_get_clientdata().

type TDbFixer

type TDbFixer = struct {
	FpParse  uintptr
	Fw       TWalker
	FpSchema uintptr
	FbTemp   Tu8
	FzDb     uintptr
	FzType   uintptr
	FpName   uintptr
}

type TDbFixer1

type TDbFixer1 = struct {
	FpParse  uintptr
	Fw       TWalker
	FpSchema uintptr
	FbTemp   Tu8
	FzDb     uintptr
	FzType   uintptr
	FpName   uintptr
}

** The following structure contains information used by the sqliteFix... ** routines as they walk the parse tree to make database references ** explicit.

type TDbPage

type TDbPage = struct {
	FpPage      uintptr
	FpData      uintptr
	FpExtra     uintptr
	FpCache     uintptr
	FpDirty     uintptr
	FpPager     uintptr
	Fpgno       TPgno
	Fflags      Tu16
	FnRef       Ti64
	FpDirtyNext uintptr
	FpDirtyPrev uintptr
}

C documentation

/*
** Handle type for pages.
*/

type TDbPath

type TDbPath = struct {
	Frc       int32
	FnSymlink int32
	FzOut     uintptr
	FnOut     int32
	FnUsed    int32
}

C documentation

/*
** A pathname under construction
*/

type TDbPath1

type TDbPath1 = struct {
	Frc       int32
	FnSymlink int32
	FzOut     uintptr
	FnOut     int32
	FnUsed    int32
}

type TDblquoteStr

type TDblquoteStr = struct {
	FpNextStr uintptr
	Fz        [8]int8
}

C documentation

/* The DblquoteStr object holds the text of a double-quoted
** string for a prepared statement.  A linked list of these objects
** is constructed during statement parsing and is held on Vdbe.pDblStr.
** When computing a normalized SQL statement for an SQL statement, that
** list is consulted for each double-quoted identifier to see if the
** identifier should really be a string literal.
*/

type TDblquoteStr1

type TDblquoteStr1 = struct {
	FpNextStr uintptr
	Fz        [8]int8
}

type TDistinctCtx

type TDistinctCtx = struct {
	FisTnct    Tu8
	FeTnctType Tu8
	FtabTnct   int32
	FaddrTnct  int32
}

C documentation

/*
** An instance of the following object is used to record information about
** how to process the DISTINCT keyword, to simplify passing that information
** into the selectInnerLoop() routine.
*/

type TDistinctCtx1

type TDistinctCtx1 = struct {
	FisTnct    Tu8
	FeTnctType Tu8
	FtabTnct   int32
	FaddrTnct  int32
}

type TDl_info

type TDl_info = struct {
	Fdli_fname uintptr
	Fdli_fbase uintptr
	Fdli_sname uintptr
	Fdli_saddr uintptr
}

type TEdupBuf

type TEdupBuf = struct {
	FzAlloc uintptr
}

C documentation

/*
** An EdupBuf is a memory allocation used to stored multiple Expr objects
** together with their Expr.zToken content.  This is used to help implement
** compression while doing sqlite3ExprDup().  The top-level Expr does the
** allocation for itself and many of its decendents, then passes an instance
** of the structure down into exprDup() so that they decendents can have
** access to that memory.
*/

type TEdupBuf1

type TEdupBuf1 = struct {
	FzAlloc uintptr
}

type TExpr

type TExpr = struct {
	Fop      Tu8
	FaffExpr int8
	Fop2     Tu8
	Fflags   Tu32
	Fu       struct {
		FiValue [0]int32
		FzToken uintptr
	}
	FpLeft  uintptr
	FpRight uintptr
	Fx      struct {
		FpSelect [0]uintptr
		FpList   uintptr
	}
	FnHeight int32
	FiTable  int32
	FiColumn TynVar
	FiAgg    Ti16
	Fw       struct {
		FiOfst [0]int32
		FiJoin int32
	}
	FpAggInfo uintptr
	Fy        struct {
		FpWin [0]uintptr
		Fsub  [0]struct {
			FiAddr     int32
			FregReturn int32
		}
		FpTab uintptr
	}
}

type TExpr1

type TExpr1 = struct {
	Fop      Tu8
	FaffExpr int8
	Fop2     Tu8
	Fflags   Tu32
	Fu       struct {
		FiValue [0]int32
		FzToken uintptr
	}
	FpLeft  uintptr
	FpRight uintptr
	Fx      struct {
		FpSelect [0]uintptr
		FpList   uintptr
	}
	FnHeight int32
	FiTable  int32
	FiColumn TynVar
	FiAgg    Ti16
	Fw       struct {
		FiOfst [0]int32
		FiJoin int32
	}
	FpAggInfo uintptr
	Fy        struct {
		FpWin [0]uintptr
		Fsub  [0]struct {
			FiAddr     int32
			FregReturn int32
		}
		FpTab uintptr
	}
}

** Each node of an expression in the parse tree is an instance ** of this structure. ** ** Expr.op is the opcode. The integer parser token codes are reused ** as opcodes here. For example, the parser defines TK_GE to be an integer ** code representing the ">=" operator. This same integer code is reused ** to represent the greater-than-or-equal-to operator in the expression ** tree. ** ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, ** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If ** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), ** then Expr.u.zToken contains the name of the function. ** ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a ** binary operator. Either or both may be NULL. ** ** Expr.x.pList is a list of arguments if the expression is an SQL function, ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)". ** Expr.x.pSelect is used if the expression is a sub-select or an expression of ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is ** valid. ** ** An expression of the form ID or ID.ID refers to a column in a table. ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is ** the integer cursor number of a VDBE cursor pointing to that table and ** Expr.iColumn is the column number for the specific column. If the ** expression is used as a result in an aggregate SELECT, then the ** value is also stored in the Expr.iAgg column in the aggregate so that ** it can be accessed after all aggregates are computed. ** ** If the expression is an unbound variable marker (a question mark ** character '?' in the original SQL) then the Expr.iTable holds the index ** number for that variable. ** ** If the expression is a subquery then Expr.iColumn holds an integer ** register number containing the result of the subquery. If the ** subquery gives a constant result, then iTable is -1. If the subquery ** gives a different answer at different times during statement processing ** then iTable is the address of a subroutine that computes the subquery. ** ** If the Expr is of type OP_Column, and the table it is selecting from ** is a disk table or the "old.*" pseudo-table, then pTab points to the ** corresponding table definition. ** ** ALLOCATION NOTES: ** ** Expr objects can use a lot of memory space in database schema. To ** help reduce memory requirements, sometimes an Expr object will be ** truncated. And to reduce the number of memory allocations, sometimes ** two or more Expr objects will be stored in a single memory allocation, ** together with Expr.u.zToken strings. ** ** If the EP_Reduced and EP_TokenOnly flags are set when ** an Expr object is truncated. When EP_Reduced is set, then all ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees ** are contained within the same memory allocation. Note, however, that ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately ** allocated, regardless of whether or not EP_Reduced is set.

type TExprList

type TExprList = struct {
	FnExpr  int32
	FnAlloc int32
	Fa      [1]TExprList_item
}

type TExprList1

type TExprList1 = struct {
	FnExpr  int32
	FnAlloc int32
	Fa      [1]TExprList_item
}

** A list of expressions. Each expression may optionally have a ** name. An expr/name combination can be used in several ways, such ** as the list of "expr AS ID" fields following a "SELECT" or in the ** list of "ID = expr" items in an UPDATE. A list of expressions can ** also be used as the argument to a function, in which case the a.zName ** field is not used. ** ** In order to try to keep memory usage down, the Expr.a.zEName field ** is used for multiple purposes: ** ** eEName Usage ** ---------- ------------------------- ** ENAME_NAME (1) the AS of result set column ** (2) COLUMN= of an UPDATE ** ** ENAME_TAB DB.TABLE.NAME used to resolve names ** of subqueries ** ** ENAME_SPAN Text of the original result set ** expression.

type TExprList_item

type TExprList_item = struct {
	FpExpr  uintptr
	FzEName uintptr
	Ffg     struct {
		F__ccgo_align  [0]uint32
		FsortFlags     Tu8
		F__ccgo_align1 [2]byte
		F__ccgo4       uint16
	}
	Fu struct {
		FiConstExprReg [0]int32
		Fx             struct {
			FiOrderByCol Tu16
			FiAlias      Tu16
		}
	}
}

C documentation

/*
** Add a new element to the end of an expression list.  If pList is
** initially NULL, then create a new expression list.
**
** The pList argument must be either NULL or a pointer to an ExprList
** obtained from a prior call to sqlite3ExprListAppend().
**
** If a memory allocation error occurs, the entire list is freed and
** NULL is returned.  If non-NULL is returned, then it is guaranteed
** that the new entry was successfully appended.
*/

type TFKey

type TFKey = struct {
	FpFrom      uintptr
	FpNextFrom  uintptr
	FzTo        uintptr
	FpNextTo    uintptr
	FpPrevTo    uintptr
	FnCol       int32
	FisDeferred Tu8
	FaAction    [2]Tu8
	FapTrigger  [2]uintptr
	FaCol       [1]TsColMap
}

type TFKey1

type TFKey1 = struct {
	FpFrom      uintptr
	FpNextFrom  uintptr
	FzTo        uintptr
	FpNextTo    uintptr
	FpPrevTo    uintptr
	FnCol       int32
	FisDeferred Tu8
	FaAction    [2]Tu8
	FapTrigger  [2]uintptr
	FaCol       [1]TsColMap
}

** Each foreign key constraint is an instance of the following structure. ** ** A foreign key is associated with two tables. The "from" table is ** the table that contains the REFERENCES clause that creates the foreign ** key. The "to" table is the table that is named in the REFERENCES clause. ** Consider this example: ** ** CREATE TABLE ex1( ** a INTEGER PRIMARY KEY, ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) ** ); ** ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". ** Equivalent names: ** ** from-table == child-table ** to-table == parent-table ** ** Each REFERENCES clause generates an instance of the following structure ** which is attached to the from-table. The to-table need not exist when ** the from-table is created. The existence of the to-table is not checked. ** ** The list of all parents for child Table X is held at X.pFKey. ** ** A list of all children for a table named Z (which might not even exist) ** is held in Schema.fkeyHash with a hash key of Z.

type TFileChunk

type TFileChunk = struct {
	FpNext  uintptr
	FzChunk [8]Tu8
}

type TFileChunk1

type TFileChunk1 = struct {
	FpNext  uintptr
	FzChunk [8]Tu8
}

** The rollback journal is composed of a linked list of these structures. ** ** The zChunk array is always at least 8 bytes in size - usually much more. ** Its actual size is stored in the MemJournal.nChunkSize variable.

type TFilePoint

type TFilePoint = struct {
	FiOffset Tsqlite3_int64
	FpChunk  uintptr
}

type TFilePoint1

type TFilePoint1 = struct {
	FiOffset Tsqlite3_int64
	FpChunk  uintptr
}

** An instance of this object serves as a cursor into the rollback journal. ** The cursor can be either for reading or writing.

type TFpDecode

type TFpDecode = struct {
	Fsign      int8
	FisSpecial int8
	Fn         int32
	FiDP       int32
	Fz         uintptr
	FzBuf      [24]int8
}

type TFpDecode1

type TFpDecode1 = struct {
	Fsign      int8
	FisSpecial int8
	Fn         int32
	FiDP       int32
	Fz         uintptr
	FzBuf      [24]int8
}

** An instance of this object receives the decoding of a floating point ** value into an approximate decimal representation.

type TFrameBound

type TFrameBound = struct {
	FeType int32
	FpExpr uintptr
}

type TFts5Auxdata

type TFts5Auxdata = struct {
	FpAux    uintptr
	FpPtr    uintptr
	FxDelete uintptr
	FpNext   uintptr
}

type TFts5Auxdata1

type TFts5Auxdata1 = struct {
	FpAux    uintptr
	FpPtr    uintptr
	FxDelete uintptr
	FpNext   uintptr
}

type TFts5Auxiliary

type TFts5Auxiliary = struct {
	FpGlobal   uintptr
	FzFunc     uintptr
	FpUserData uintptr
	FxFunc     Tfts5_extension_function
	FxDestroy  uintptr
	FpNext     uintptr
}

type TFts5Auxiliary1

type TFts5Auxiliary1 = struct {
	FpGlobal   uintptr
	FzFunc     uintptr
	FpUserData uintptr
	FxFunc     Tfts5_extension_function
	FxDestroy  uintptr
	FpNext     uintptr
}

** Each auxiliary function registered with the FTS5 module is represented ** by an object of the following type. All such objects are stored as part ** of the Fts5Global.pAux list.

type TFts5Bm25Data

type TFts5Bm25Data = struct {
	FnPhrase int32
	Favgdl   float64
	FaIDF    uintptr
	FaFreq   uintptr
}

C documentation

/*
** The first time the bm25() function is called for a query, an instance
** of the following structure is allocated and populated.
*/

type TFts5Bm25Data1

type TFts5Bm25Data1 = struct {
	FnPhrase int32
	Favgdl   float64
	FaIDF    uintptr
	FaFreq   uintptr
}

type TFts5Buffer

type TFts5Buffer = struct {
	Fp      uintptr
	Fn      int32
	FnSpace int32
}

C documentation

/*
** Buffer object for the incremental building of string data.
*/

type TFts5Buffer1

type TFts5Buffer1 = struct {
	Fp      uintptr
	Fn      int32
	FnSpace int32
}

type TFts5CResult

type TFts5CResult = struct {
	FiFirst  Tu16
	FbTermEq Tu8
}

type TFts5CResult1

type TFts5CResult1 = struct {
	FiFirst  Tu16
	FbTermEq Tu8
}

type TFts5Colset

type TFts5Colset = struct {
	FnCol  int32
	FaiCol [1]int32
}

type TFts5Colset1

type TFts5Colset1 = struct {
	FnCol  int32
	FaiCol [1]int32
}

If a NEAR() clump or phrase may only match a specific set of columns,

** then an object of the following type is used to record the set of columns. ** Each entry in the aiCol[] array is a column that may be matched. ** ** This object is used by fts5_expr.c and fts5_index.c.

type TFts5Config

type TFts5Config = struct {
	Fdb                 uintptr
	FzDb                uintptr
	FzName              uintptr
	FnCol               int32
	FazCol              uintptr
	FabUnindexed        uintptr
	FnPrefix            int32
	FaPrefix            uintptr
	FeContent           int32
	FbContentlessDelete int32
	FzContent           uintptr
	FzContentRowid      uintptr
	FbColumnsize        int32
	FbTokendata         int32
	FeDetail            int32
	FzContentExprlist   uintptr
	FpTok               uintptr
	FpTokApi            uintptr
	FbLock              int32
	FePattern           int32
	FiVersion           int32
	FiCookie            int32
	Fpgsz               int32
	FnAutomerge         int32
	FnCrisisMerge       int32
	FnUsermerge         int32
	FnHashSize          int32
	FzRank              uintptr
	FzRankArgs          uintptr
	FbSecureDelete      int32
	FnDeleteMerge       int32
	FpzErrmsg           uintptr
}

type TFts5Config1

type TFts5Config1 = struct {
	Fdb                 uintptr
	FzDb                uintptr
	FzName              uintptr
	FnCol               int32
	FazCol              uintptr
	FabUnindexed        uintptr
	FnPrefix            int32
	FaPrefix            uintptr
	FeContent           int32
	FbContentlessDelete int32
	FzContent           uintptr
	FzContentRowid      uintptr
	FbColumnsize        int32
	FbTokendata         int32
	FeDetail            int32
	FzContentExprlist   uintptr
	FpTok               uintptr
	FpTokApi            uintptr
	FbLock              int32
	FePattern           int32
	FiVersion           int32
	FiCookie            int32
	Fpgsz               int32
	FnAutomerge         int32
	FnCrisisMerge       int32
	FnUsermerge         int32
	FnHashSize          int32
	FzRank              uintptr
	FzRankArgs          uintptr
	FbSecureDelete      int32
	FnDeleteMerge       int32
	FpzErrmsg           uintptr
}

** An instance of the following structure encodes all information that can ** be gleaned from the CREATE VIRTUAL TABLE statement. ** ** And all information loaded from the %_config table. ** ** nAutomerge: ** The minimum number of segments that an auto-merge operation should ** attempt to merge together. A value of 1 sets the object to use the ** compile time default. Zero disables auto-merge altogether. ** ** bContentlessDelete: ** True if the contentless_delete option was present in the CREATE ** VIRTUAL TABLE statement. ** ** zContent: ** ** zContentRowid: ** The value of the content_rowid= option, if one was specified. Or ** the string "rowid" otherwise. This text is not quoted - if it is ** used as part of an SQL statement it needs to be quoted appropriately. ** ** zContentExprlist: ** ** pzErrmsg: ** This exists in order to allow the fts5_index.c module to return a ** decent error message if it encounters a file-format version it does ** not understand. ** ** bColumnsize: ** True if the %_docsize table is created. ** ** bPrefixIndex: ** This is only used for debugging. If set to false, any prefix indexes ** are ignored. This value is configured using: ** ** INSERT INTO tbl(tbl, rank) VALUES('prefix-index', $bPrefixIndex); **

type TFts5Cursor

type TFts5Cursor = struct {
	Fbase         Tsqlite3_vtab_cursor
	FpNext        uintptr
	FaColumnSize  uintptr
	FiCsrId       Ti64
	FePlan        int32
	FbDesc        int32
	FiFirstRowid  Ti64
	FiLastRowid   Ti64
	FpStmt        uintptr
	FpExpr        uintptr
	FpSorter      uintptr
	Fcsrflags     int32
	FiSpecial     Ti64
	FzRank        uintptr
	FzRankArgs    uintptr
	FpRank        uintptr
	FnRankArg     int32
	FapRankArg    uintptr
	FpRankArgStmt uintptr
	FpAux         uintptr
	FpAuxdata     uintptr
	FaInstIter    uintptr
	FnInstAlloc   int32
	FnInstCount   int32
	FaInst        uintptr
}

type TFts5Cursor1

type TFts5Cursor1 = struct {
	Fbase         Tsqlite3_vtab_cursor
	FpNext        uintptr
	FaColumnSize  uintptr
	FiCsrId       Ti64
	FePlan        int32
	FbDesc        int32
	FiFirstRowid  Ti64
	FiLastRowid   Ti64
	FpStmt        uintptr
	FpExpr        uintptr
	FpSorter      uintptr
	Fcsrflags     int32
	FiSpecial     Ti64
	FzRank        uintptr
	FzRankArgs    uintptr
	FpRank        uintptr
	FnRankArg     int32
	FapRankArg    uintptr
	FpRankArgStmt uintptr
	FpAux         uintptr
	FpAuxdata     uintptr
	FaInstIter    uintptr
	FnInstAlloc   int32
	FnInstCount   int32
	FaInst        uintptr
}

** Virtual-table cursor object. ** ** iSpecial: ** If this is a 'special' query (refer to function fts5SpecialMatch()), ** then this variable contains the result of the query. ** ** iFirstRowid, iLastRowid: ** These variables are only used for FTS5_PLAN_MATCH cursors. Assuming the ** cursor iterates in ascending order of rowids, iFirstRowid is the lower ** limit of rowids to return, and iLastRowid the upper. In other words, the ** WHERE clause in the user's query might have been: ** ** <tbl> MATCH <expr> AND rowid BETWEEN $iFirstRowid AND $iLastRowid ** ** If the cursor iterates in descending order of rowid, iFirstRowid ** is the upper limit (i.e. the "first" rowid visited) and iLastRowid ** the lower.

type TFts5Data

type TFts5Data = struct {
	Fp      uintptr
	Fnn     int32
	FszLeaf int32
}

type TFts5Data1

type TFts5Data1 = struct {
	Fp      uintptr
	Fnn     int32
	FszLeaf int32
}

type TFts5DlidxIter

type TFts5DlidxIter = struct {
	FnLvl   int32
	FiSegid int32
	FaLvl   [1]TFts5DlidxLvl
}

type TFts5DlidxIter1

type TFts5DlidxIter1 = struct {
	FnLvl   int32
	FiSegid int32
	FaLvl   [1]TFts5DlidxLvl
}

type TFts5DlidxLvl

type TFts5DlidxLvl = struct {
	FpData     uintptr
	FiOff      int32
	FbEof      int32
	FiFirstOff int32
	FiLeafPgno int32
	FiRowid    Ti64
}

type TFts5DlidxLvl1

type TFts5DlidxLvl1 = struct {
	FpData     uintptr
	FiOff      int32
	FbEof      int32
	FiFirstOff int32
	FiLeafPgno int32
	FiRowid    Ti64
}

** An instance of the following type is used to iterate through the contents ** of a doclist-index record. ** ** pData: ** Record containing the doclist-index data. ** ** bEof: ** Set to true once iterator has reached EOF. ** ** iOff: ** Set to the current offset within record pData.

type TFts5DlidxWriter

type TFts5DlidxWriter = struct {
	Fpgno       int32
	FbPrevValid int32
	FiPrev      Ti64
	Fbuf        TFts5Buffer
}

type TFts5DlidxWriter1

type TFts5DlidxWriter1 = struct {
	Fpgno       int32
	FbPrevValid int32
	FiPrev      Ti64
	Fbuf        TFts5Buffer
}

type TFts5DoclistIter

type TFts5DoclistIter = struct {
	FaEof     uintptr
	FiRowid   Ti64
	FaPoslist uintptr
	FnPoslist int32
	FnSize    int32
}

type TFts5DoclistIter1

type TFts5DoclistIter1 = struct {
	FaEof     uintptr
	FiRowid   Ti64
	FaPoslist uintptr
	FnPoslist int32
	FnSize    int32
}

type TFts5Enum

type TFts5Enum = struct {
	FzName uintptr
	FeVal  int32
}

type TFts5Enum1

type TFts5Enum1 = struct {
	FzName uintptr
	FeVal  int32
}

type TFts5Expr

type TFts5Expr = struct {
	FpIndex       uintptr
	FpConfig      uintptr
	FpRoot        uintptr
	FbDesc        int32
	FnPhrase      int32
	FapExprPhrase uintptr
}

C documentation

/**************************************************************************
** Interface to code in fts5_expr.c.
*/

type TFts5Expr1

type TFts5Expr1 = struct {
	FpIndex       uintptr
	FpConfig      uintptr
	FpRoot        uintptr
	FbDesc        int32
	FnPhrase      int32
	FapExprPhrase uintptr
}

type TFts5ExprCtx

type TFts5ExprCtx = struct {
	FpExpr      uintptr
	FaPopulator uintptr
	FiOff       Ti64
}

type TFts5ExprCtx1

type TFts5ExprCtx1 = struct {
	FpExpr      uintptr
	FaPopulator uintptr
	FiOff       Ti64
}

type TFts5ExprNearset

type TFts5ExprNearset = struct {
	FnNear    int32
	FpColset  uintptr
	FnPhrase  int32
	FapPhrase [1]uintptr
}

type TFts5ExprNearset1

type TFts5ExprNearset1 = struct {
	FnNear    int32
	FpColset  uintptr
	FnPhrase  int32
	FapPhrase [1]uintptr
}

** One or more phrases that must appear within a certain token distance of ** each other within each matching document.

type TFts5ExprNode

type TFts5ExprNode = struct {
	FeType    int32
	FbEof     int32
	FbNomatch int32
	FiHeight  int32
	FxNext    uintptr
	FiRowid   Ti64
	FpNear    uintptr
	FnChild   int32
	FapChild  [1]uintptr
}

type TFts5ExprNode1

type TFts5ExprNode1 = struct {
	FeType    int32
	FbEof     int32
	FbNomatch int32
	FiHeight  int32
	FxNext    uintptr
	FiRowid   Ti64
	FpNear    uintptr
	FnChild   int32
	FapChild  [1]uintptr
}

** eType: ** Expression node type. Always one of: ** ** FTS5_AND (nChild, apChild valid) ** FTS5_OR (nChild, apChild valid) ** FTS5_NOT (nChild, apChild valid) ** FTS5_STRING (pNear valid) ** FTS5_TERM (pNear valid) ** ** iHeight: ** Distance from this node to furthest leaf. This is always 0 for nodes ** of type FTS5_STRING and FTS5_TERM. For all other nodes it is one ** greater than the largest child value.

type TFts5ExprPhrase

type TFts5ExprPhrase = struct {
	FpNode   uintptr
	Fposlist TFts5Buffer
	FnTerm   int32
	FaTerm   [1]TFts5ExprTerm
}

type TFts5ExprPhrase1

type TFts5ExprPhrase1 = struct {
	FpNode   uintptr
	Fposlist TFts5Buffer
	FnTerm   int32
	FaTerm   [1]TFts5ExprTerm
}

** A phrase. One or more terms that must appear in a contiguous sequence ** within a document for it to match.

type TFts5ExprTerm

type TFts5ExprTerm = struct {
	FbPrefix    Tu8
	FbFirst     Tu8
	FpTerm      uintptr
	FnQueryTerm int32
	FnFullTerm  int32
	FpIter      uintptr
	FpSynonym   uintptr
}

type TFts5ExprTerm1

type TFts5ExprTerm1 = struct {
	FbPrefix    Tu8
	FbFirst     Tu8
	FpTerm      uintptr
	FnQueryTerm int32
	FnFullTerm  int32
	FpIter      uintptr
	FpSynonym   uintptr
}

** An instance of the following structure represents a single search term ** or term prefix.

type TFts5ExtensionApi

type TFts5ExtensionApi = struct {
	FiVersion           int32
	FxUserData          uintptr
	FxColumnCount       uintptr
	FxRowCount          uintptr
	FxColumnTotalSize   uintptr
	FxTokenize          uintptr
	FxPhraseCount       uintptr
	FxPhraseSize        uintptr
	FxInstCount         uintptr
	FxInst              uintptr
	FxRowid             uintptr
	FxColumnText        uintptr
	FxColumnSize        uintptr
	FxQueryPhrase       uintptr
	FxSetAuxdata        uintptr
	FxGetAuxdata        uintptr
	FxPhraseFirst       uintptr
	FxPhraseNext        uintptr
	FxPhraseFirstColumn uintptr
	FxPhraseNextColumn  uintptr
	FxQueryToken        uintptr
	FxInstToken         uintptr
}

type TFts5ExtensionApi1

type TFts5ExtensionApi1 = struct {
	FiVersion           int32
	FxUserData          uintptr
	FxColumnCount       uintptr
	FxRowCount          uintptr
	FxColumnTotalSize   uintptr
	FxTokenize          uintptr
	FxPhraseCount       uintptr
	FxPhraseSize        uintptr
	FxInstCount         uintptr
	FxInst              uintptr
	FxRowid             uintptr
	FxColumnText        uintptr
	FxColumnSize        uintptr
	FxQueryPhrase       uintptr
	FxSetAuxdata        uintptr
	FxGetAuxdata        uintptr
	FxPhraseFirst       uintptr
	FxPhraseNext        uintptr
	FxPhraseFirstColumn uintptr
	FxPhraseNextColumn  uintptr
	FxQueryToken        uintptr
	FxInstToken         uintptr
}

** EXTENSION API FUNCTIONS ** ** xUserData(pFts): ** Return a copy of the pUserData pointer passed to the xCreateFunction() ** API when the extension function was registered. ** ** xColumnTotalSize(pFts, iCol, pnToken): ** If parameter iCol is less than zero, set output variable *pnToken ** to the total number of tokens in the FTS5 table. Or, if iCol is ** non-negative but less than the number of columns in the table, return ** the total number of tokens in column iCol, considering all rows in ** the FTS5 table. ** ** If parameter iCol is greater than or equal to the number of columns ** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. ** an OOM condition or IO error), an appropriate SQLite error code is ** returned. ** ** xColumnCount(pFts): ** Return the number of columns in the table. ** ** xColumnSize(pFts, iCol, pnToken): ** If parameter iCol is less than zero, set output variable *pnToken ** to the total number of tokens in the current row. Or, if iCol is ** non-negative but less than the number of columns in the table, set ** *pnToken to the number of tokens in column iCol of the current row. ** ** If parameter iCol is greater than or equal to the number of columns ** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. ** an OOM condition or IO error), an appropriate SQLite error code is ** returned. ** ** This function may be quite inefficient if used with an FTS5 table ** created with the "columnsize=0" option. ** ** xColumnText: ** If parameter iCol is less than zero, or greater than or equal to the ** number of columns in the table, SQLITE_RANGE is returned. ** ** Otherwise, this function attempts to retrieve the text of column iCol of ** the current document. If successful, (*pz) is set to point to a buffer ** containing the text in utf-8 encoding, (*pn) is set to the size in bytes ** (not characters) of the buffer and SQLITE_OK is returned. Otherwise, ** if an error occurs, an SQLite error code is returned and the final values ** of (*pz) and (*pn) are undefined. ** ** xPhraseCount: ** Returns the number of phrases in the current query expression. ** ** xPhraseSize: ** If parameter iCol is less than zero, or greater than or equal to the ** number of phrases in the current query, as returned by xPhraseCount, ** 0 is returned. Otherwise, this function returns the number of tokens in ** phrase iPhrase of the query. Phrases are numbered starting from zero. ** ** xInstCount: ** Set *pnInst to the total number of occurrences of all phrases within ** the query within the current row. Return SQLITE_OK if successful, or ** an error code (i.e. SQLITE_NOMEM) if an error occurs. ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" or "detail=column" option. If the FTS5 table is created ** with either "detail=none" or "detail=column" and "content=" option ** (i.e. if it is a contentless table), then this API always returns 0. ** ** xInst: ** Query for the details of phrase match iIdx within the current row. ** Phrase matches are numbered starting from zero, so the iIdx argument ** should be greater than or equal to zero and smaller than the value ** output by xInstCount(). If iIdx is less than zero or greater than ** or equal to the value returned by xInstCount(), SQLITE_RANGE is returned. ** ** Otherwise, output parameter *piPhrase is set to the phrase number, *piCol ** to the column in which it occurs and *piOff the token offset of the ** first token of the phrase. SQLITE_OK is returned if successful, or an ** error code (i.e. SQLITE_NOMEM) if an error occurs. ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" or "detail=column" option. ** ** xRowid: ** Returns the rowid of the current row. ** ** xTokenize: ** Tokenize text using the tokenizer belonging to the FTS5 table. ** ** xQueryPhrase(pFts5, iPhrase, pUserData, xCallback): ** This API function is used to query the FTS table for phrase iPhrase ** of the current query. Specifically, a query equivalent to: ** ** ... FROM ftstable WHERE ftstable MATCH $p ORDER BY rowid ** ** with $p set to a phrase equivalent to the phrase iPhrase of the ** current query is executed. Any column filter that applies to ** phrase iPhrase of the current query is included in $p. For each ** row visited, the callback function passed as the fourth argument ** is invoked. The context and API objects passed to the callback ** function may be used to access the properties of each matched row. ** Invoking Api.xUserData() returns a copy of the pointer passed as ** the third argument to pUserData. ** ** If parameter iPhrase is less than zero, or greater than or equal to ** the number of phrases in the query, as returned by xPhraseCount(), ** this function returns SQLITE_RANGE. ** ** If the callback function returns any value other than SQLITE_OK, the ** query is abandoned and the xQueryPhrase function returns immediately. ** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK. ** Otherwise, the error code is propagated upwards. ** ** If the query runs to completion without incident, SQLITE_OK is returned. ** Or, if some error occurs before the query completes or is aborted by ** the callback, an SQLite error code is returned. ** ** ** xSetAuxdata(pFts5, pAux, xDelete) ** ** Save the pointer passed as the second argument as the extension function's ** "auxiliary data". The pointer may then be retrieved by the current or any ** future invocation of the same fts5 extension function made as part of ** the same MATCH query using the xGetAuxdata() API. ** ** Each extension function is allocated a single auxiliary data slot for ** each FTS query (MATCH expression). If the extension function is invoked ** more than once for a single FTS query, then all invocations share a ** single auxiliary data context. ** ** If there is already an auxiliary data pointer when this function is ** invoked, then it is replaced by the new pointer. If an xDelete callback ** was specified along with the original pointer, it is invoked at this ** point. ** ** The xDelete callback, if one is specified, is also invoked on the ** auxiliary data pointer after the FTS5 query has finished. ** ** If an error (e.g. an OOM condition) occurs within this function, ** the auxiliary data is set to NULL and an error code returned. If the ** xDelete parameter was not NULL, it is invoked on the auxiliary data ** pointer before returning. ** ** ** xGetAuxdata(pFts5, bClear) ** ** Returns the current auxiliary data pointer for the fts5 extension ** function. See the xSetAuxdata() method for details. ** ** If the bClear argument is non-zero, then the auxiliary data is cleared ** (set to NULL) before this function returns. In this case the xDelete, ** if any, is not invoked. ** ** ** xRowCount(pFts5, pnRow) ** ** This function is used to retrieve the total number of rows in the table. ** In other words, the same value that would be returned by: ** ** SELECT count(*) FROM ftstable; ** ** xPhraseFirst() ** This function is used, along with type Fts5PhraseIter and the xPhraseNext ** method, to iterate through all instances of a single query phrase within ** the current row. This is the same information as is accessible via the ** xInstCount/xInst APIs. While the xInstCount/xInst APIs are more convenient ** to use, this API may be faster under some circumstances. To iterate ** through instances of phrase iPhrase, use the following code: ** ** Fts5PhraseIter iter; ** int iCol, iOff; ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff); ** iCol>=0; ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff) ** ){ ** // An instance of phrase iPhrase at offset iOff of column iCol ** } ** ** The Fts5PhraseIter structure is defined above. Applications should not ** modify this structure directly - it should only be used as shown above ** with the xPhraseFirst() and xPhraseNext() API methods (and by ** xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below). ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" or "detail=column" option. If the FTS5 table is created ** with either "detail=none" or "detail=column" and "content=" option ** (i.e. if it is a contentless table), then this API always iterates ** through an empty set (all calls to xPhraseFirst() set iCol to -1). ** ** xPhraseNext() ** See xPhraseFirst above. ** ** xPhraseFirstColumn() ** This function and xPhraseNextColumn() are similar to the xPhraseFirst() ** and xPhraseNext() APIs described above. The difference is that instead ** of iterating through all instances of a phrase in the current row, these ** APIs are used to iterate through the set of columns in the current row ** that contain one or more instances of a specified phrase. For example: ** ** Fts5PhraseIter iter; ** int iCol; ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol); ** iCol>=0; ** pApi->xPhraseNextColumn(pFts, &iter, &iCol) ** ){ ** // Column iCol contains at least one instance of phrase iPhrase ** } ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" option. If the FTS5 table is created with either ** "detail=none" "content=" option (i.e. if it is a contentless table), ** then this API always iterates through an empty set (all calls to ** xPhraseFirstColumn() set iCol to -1). ** ** The information accessed using this API and its companion ** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext ** (or xInst/xInstCount). The chief advantage of this API is that it is ** significantly more efficient than those alternatives when used with ** "detail=column" tables. ** ** xPhraseNextColumn() ** See xPhraseFirstColumn above. ** ** xQueryToken(pFts5, iPhrase, iToken, ppToken, pnToken) ** This is used to access token iToken of phrase iPhrase of the current ** query. Before returning, output parameter *ppToken is set to point ** to a buffer containing the requested token, and *pnToken to the ** size of this buffer in bytes. ** ** If iPhrase or iToken are less than zero, or if iPhrase is greater than ** or equal to the number of phrases in the query as reported by ** xPhraseCount(), or if iToken is equal to or greater than the number of ** tokens in the phrase, SQLITE_RANGE is returned and *ppToken and *pnToken

are both zeroed.

** ** The output text is not a copy of the query text that specified the ** token. It is the output of the tokenizer module. For tokendata=1 ** tables, this includes any embedded 0x00 and trailing data. ** ** xInstToken(pFts5, iIdx, iToken, ppToken, pnToken) ** This is used to access token iToken of phrase hit iIdx within the ** current row. If iIdx is less than zero or greater than or equal to the ** value returned by xInstCount(), SQLITE_RANGE is returned. Otherwise, ** output variable (*ppToken) is set to point to a buffer containing the ** matching document token, and (*pnToken) to the size of that buffer in ** bytes. This API is not available if the specified token matches a ** prefix query term. In that case both output variables are always set ** to 0. ** ** The output text is not a copy of the document text that was tokenized. ** It is the output of the tokenizer module. For tokendata=1 tables, this ** includes any embedded 0x00 and trailing data. ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" or "detail=column" option.

type TFts5FlushCtx

type TFts5FlushCtx = struct {
	FpIdx   uintptr
	Fwriter TFts5SegWriter
}

type TFts5FlushCtx1

type TFts5FlushCtx1 = struct {
	FpIdx   uintptr
	Fwriter TFts5SegWriter
}

type TFts5FullTable

type TFts5FullTable = struct {
	Fp          TFts5Table
	FpStorage   uintptr
	FpGlobal    uintptr
	FpSortCsr   uintptr
	FiSavepoint int32
}

type TFts5FullTable1

type TFts5FullTable1 = struct {
	Fp          TFts5Table
	FpStorage   uintptr
	FpGlobal    uintptr
	FpSortCsr   uintptr
	FiSavepoint int32
}

type TFts5Global

type TFts5Global = struct {
	Fapi      Tfts5_api
	Fdb       uintptr
	FiNextId  Ti64
	FpAux     uintptr
	FpTok     uintptr
	FpDfltTok uintptr
	FpCsr     uintptr
}

type TFts5Global1

type TFts5Global1 = struct {
	Fapi      Tfts5_api
	Fdb       uintptr
	FiNextId  Ti64
	FpAux     uintptr
	FpTok     uintptr
	FpDfltTok uintptr
	FpCsr     uintptr
}

** A single object of this type is allocated when the FTS5 module is ** registered with a database handle. It is used to store pointers to ** all registered FTS5 extensions - tokenizers and auxiliary functions.

type TFts5Hash

type TFts5Hash = struct {
	FeDetail int32
	FpnByte  uintptr
	FnEntry  int32
	FnSlot   int32
	FpScan   uintptr
	FaSlot   uintptr
}

C documentation

/**************************************************************************
** Interface to code in fts5_hash.c.
*/

type TFts5Hash1

type TFts5Hash1 = struct {
	FeDetail int32
	FpnByte  uintptr
	FnEntry  int32
	FnSlot   int32
	FpScan   uintptr
	FaSlot   uintptr
}

type TFts5HashEntry

type TFts5HashEntry = struct {
	FpHashNext  uintptr
	FpScanNext  uintptr
	FnAlloc     int32
	FiSzPoslist int32
	FnData      int32
	FnKey       int32
	FbDel       Tu8
	FbContent   Tu8
	FiCol       Ti16
	FiPos       int32
	FiRowid     Ti64
}

type TFts5HashEntry1

type TFts5HashEntry1 = struct {
	FpHashNext  uintptr
	FpScanNext  uintptr
	FnAlloc     int32
	FiSzPoslist int32
	FnData      int32
	FnKey       int32
	FbDel       Tu8
	FbContent   Tu8
	FiCol       Ti16
	FiPos       int32
	FiRowid     Ti64
}

** Each entry in the hash table is represented by an object of the ** following type. Each object, its key, and its current data are stored ** in a single memory allocation. The key immediately follows the object ** in memory. The position list data immediately follows the key data ** in memory. ** ** The key is Fts5HashEntry.nKey bytes in size. It consists of a single ** byte identifying the index (either the main term index or a prefix-index), ** followed by the term data. For example: "0token". There is no ** nul-terminator - in this case nKey=6. ** ** The data that follows the key is in a similar, but not identical format ** to the doclist data stored in the database. It is: ** ** * Rowid, as a varint ** * Position list, without 0x00 terminator. ** * Size of previous position list and rowid, as a 4 byte ** big-endian integer. ** ** iRowidOff: ** Offset of last rowid written to data area. Relative to first byte of ** structure. ** ** nData: ** Bytes of data written since iRowidOff.

type TFts5Index

type TFts5Index = struct {
	FpConfig            uintptr
	FzDataTbl           uintptr
	FnWorkUnit          int32
	FpHash              uintptr
	FnPendingData       int32
	FiWriteRowid        Ti64
	FbDelete            int32
	FnContentlessDelete int32
	FnPendingRow        int32
	Frc                 int32
	FflushRc            int32
	FpReader            uintptr
	FpWriter            uintptr
	FpDeleter           uintptr
	FpIdxWriter         uintptr
	FpIdxDeleter        uintptr
	FpIdxSelect         uintptr
	FpIdxNextSelect     uintptr
	FnRead              int32
	FpDeleteFromIdx     uintptr
	FpDataVersion       uintptr
	FiStructVersion     Ti64
	FpStruct            uintptr
}

type TFts5Index1

type TFts5Index1 = struct {
	FpConfig            uintptr
	FzDataTbl           uintptr
	FnWorkUnit          int32
	FpHash              uintptr
	FnPendingData       int32
	FiWriteRowid        Ti64
	FbDelete            int32
	FnContentlessDelete int32
	FnPendingRow        int32
	Frc                 int32
	FflushRc            int32
	FpReader            uintptr
	FpWriter            uintptr
	FpDeleter           uintptr
	FpIdxWriter         uintptr
	FpIdxDeleter        uintptr
	FpIdxSelect         uintptr
	FpIdxNextSelect     uintptr
	FnRead              int32
	FpDeleteFromIdx     uintptr
	FpDataVersion       uintptr
	FiStructVersion     Ti64
	FpStruct            uintptr
}

** One object per %_data table. ** ** nContentlessDelete: ** The number of contentless delete operations since the most recent ** call to fts5IndexFlush() or fts5IndexDiscardData(). This is tracked ** so that extra auto-merge work can be done by fts5IndexFlush() to ** account for the delete operations.

type TFts5IndexIter

type TFts5IndexIter = struct {
	FiRowid Ti64
	FpData  uintptr
	FnData  int32
	FbEof   Tu8
}

type TFts5IndexIter1

type TFts5IndexIter1 = struct {
	FiRowid Ti64
	FpData  uintptr
	FnData  int32
	FbEof   Tu8
}

type TFts5InsertCtx

type TFts5InsertCtx = struct {
	FpStorage uintptr
	FiCol     int32
	FszCol    int32
}

type TFts5InsertCtx1

type TFts5InsertCtx1 = struct {
	FpStorage uintptr
	FiCol     int32
	FszCol    int32
}

type TFts5IntegrityCtx

type TFts5IntegrityCtx = struct {
	FiRowid   Ti64
	FiCol     int32
	FszCol    int32
	Fcksum    Tu64
	FpTermset uintptr
	FpConfig  uintptr
}

C documentation

/*
** Context object used by sqlite3Fts5StorageIntegrity().
*/

type TFts5IntegrityCtx1

type TFts5IntegrityCtx1 = struct {
	FiRowid   Ti64
	FiCol     int32
	FszCol    int32
	Fcksum    Tu64
	FpTermset uintptr
	FpConfig  uintptr
}

type TFts5Iter

type TFts5Iter = struct {
	Fbase           TFts5IndexIter
	FpTokenDataIter uintptr
	FpIndex         uintptr
	Fposlist        TFts5Buffer
	FpColset        uintptr
	FxSetOutputs    uintptr
	FnSeg           int32
	FbRev           int32
	FbSkipEmpty     Tu8
	FiSwitchRowid   Ti64
	FaFirst         uintptr
	FaSeg           [1]TFts5SegIter
}

type TFts5Iter1

type TFts5Iter1 = struct {
	Fbase           TFts5IndexIter
	FpTokenDataIter uintptr
	FpIndex         uintptr
	Fposlist        TFts5Buffer
	FpColset        uintptr
	FxSetOutputs    uintptr
	FnSeg           int32
	FbRev           int32
	FbSkipEmpty     Tu8
	FiSwitchRowid   Ti64
	FaFirst         uintptr
	FaSeg           [1]TFts5SegIter
}

** Object for iterating through the merged results of one or more segments, ** visiting each term/rowid pair in the merged data. ** ** nSeg is always a power of two greater than or equal to the number of ** segments that this object is merging data from. Both the aSeg[] and ** aFirst[] arrays are sized at nSeg entries. The aSeg[] array is padded ** with zeroed objects - these are handled as if they were iterators opened ** on empty segments. ** ** The results of comparing segments aSeg[N] and aSeg[N+1], where N is an ** even number, is stored in aFirst[(nSeg+N)/2]. The "result" of the ** comparison in this context is the index of the iterator that currently ** points to the smaller term/rowid combination. Iterators at EOF are ** considered to be greater than all other iterators. ** ** aFirst[1] contains the index in aSeg[] of the iterator that points to ** the smallest key overall. aFirst[0] is unused. ** ** poslist: ** Used by sqlite3Fts5IterPoslist() when the poslist needs to be buffered. ** There is no way to tell if this is populated or not. ** ** pColset: ** If not NULL, points to an object containing a set of column indices. ** Only matches that occur in one of these columns will be returned. ** The Fts5Iter does not own the Fts5Colset object, and so it is not ** freed when the iterator is closed - it is owned by the upper layer.

type TFts5LookaheadReader

type TFts5LookaheadReader = struct {
	Fa          uintptr
	Fn          int32
	Fi          int32
	FiPos       Ti64
	FiLookahead Ti64
}

type TFts5LookaheadReader1

type TFts5LookaheadReader1 = struct {
	Fa          uintptr
	Fn          int32
	Fi          int32
	FiPos       Ti64
	FiLookahead Ti64
}

type TFts5MatchPhrase

type TFts5MatchPhrase = struct {
	FpPoslist uintptr
	FnTerm    int32
}

type TFts5NearTrimmer

type TFts5NearTrimmer = struct {
	Freader TFts5LookaheadReader
	Fwriter TFts5PoslistWriter
	FpOut   uintptr
}

type TFts5NearTrimmer1

type TFts5NearTrimmer1 = struct {
	Freader TFts5LookaheadReader
	Fwriter TFts5PoslistWriter
	FpOut   uintptr
}

type TFts5PageWriter

type TFts5PageWriter = struct {
	Fpgno       int32
	FiPrevPgidx int32
	Fbuf        TFts5Buffer
	Fpgidx      TFts5Buffer
	Fterm       TFts5Buffer
}

type TFts5PageWriter1

type TFts5PageWriter1 = struct {
	Fpgno       int32
	FiPrevPgidx int32
	Fbuf        TFts5Buffer
	Fpgidx      TFts5Buffer
	Fterm       TFts5Buffer
}

** An object of type Fts5SegWriter is used to write to segments.

type TFts5Parse

type TFts5Parse = struct {
	FpConfig      uintptr
	FzErr         uintptr
	Frc           int32
	FnPhrase      int32
	FapPhrase     uintptr
	FpExpr        uintptr
	FbPhraseToAnd int32
}

type TFts5Parse1

type TFts5Parse1 = struct {
	FpConfig      uintptr
	FzErr         uintptr
	Frc           int32
	FnPhrase      int32
	FapPhrase     uintptr
	FpExpr        uintptr
	FbPhraseToAnd int32
}

** Parse context.

type TFts5PhraseIter

type TFts5PhraseIter = struct {
	Fa uintptr
	Fb uintptr
}

type TFts5PhraseIter1

type TFts5PhraseIter1 = struct {
	Fa uintptr
	Fb uintptr
}

type TFts5PoslistPopulator

type TFts5PoslistPopulator = struct {
	Fwriter TFts5PoslistWriter
	FbOk    int32
	FbMiss  int32
}

type TFts5PoslistPopulator1

type TFts5PoslistPopulator1 = struct {
	Fwriter TFts5PoslistWriter
	FbOk    int32
	FbMiss  int32
}

type TFts5PoslistReader

type TFts5PoslistReader = struct {
	Fa     uintptr
	Fn     int32
	Fi     int32
	FbFlag Tu8
	FbEof  Tu8
	FiPos  Ti64
}

type TFts5PoslistReader1

type TFts5PoslistReader1 = struct {
	Fa     uintptr
	Fn     int32
	Fi     int32
	FbFlag Tu8
	FbEof  Tu8
	FiPos  Ti64
}

type TFts5PoslistWriter

type TFts5PoslistWriter = struct {
	FiPrev Ti64
}

type TFts5PoslistWriter1

type TFts5PoslistWriter1 = struct {
	FiPrev Ti64
}

type TFts5SFinder

type TFts5SFinder = struct {
	FiPos        int32
	FnFirstAlloc int32
	FnFirst      int32
	FaFirst      uintptr
	FzDoc        uintptr
}

C documentation

/*
** Context object passed to the fts5SentenceFinderCb() function.
*/

type TFts5SFinder1

type TFts5SFinder1 = struct {
	FiPos        int32
	FnFirstAlloc int32
	FnFirst      int32
	FaFirst      uintptr
	FzDoc        uintptr
}

type TFts5SegIter

type TFts5SegIter = struct {
	FpSeg            uintptr
	Fflags           int32
	FiLeafPgno       int32
	FpLeaf           uintptr
	FpNextLeaf       uintptr
	FiLeafOffset     Ti64
	FpTombArray      uintptr
	FxNext           uintptr
	FiTermLeafPgno   int32
	FiTermLeafOffset int32
	FiPgidxOff       int32
	FiEndofDoclist   int32
	FiRowidOffset    int32
	FnRowidOffset    int32
	FaRowidOffset    uintptr
	FpDlidx          uintptr
	Fterm            TFts5Buffer
	FiRowid          Ti64
	FnPos            int32
	FbDel            Tu8
}

type TFts5SegIter1

type TFts5SegIter1 = struct {
	FpSeg            uintptr
	Fflags           int32
	FiLeafPgno       int32
	FpLeaf           uintptr
	FpNextLeaf       uintptr
	FiLeafOffset     Ti64
	FpTombArray      uintptr
	FxNext           uintptr
	FiTermLeafPgno   int32
	FiTermLeafOffset int32
	FiPgidxOff       int32
	FiEndofDoclist   int32
	FiRowidOffset    int32
	FnRowidOffset    int32
	FaRowidOffset    uintptr
	FpDlidx          uintptr
	Fterm            TFts5Buffer
	FiRowid          Ti64
	FnPos            int32
	FbDel            Tu8
}

** Object for iterating through a single segment, visiting each term/rowid ** pair in the segment. ** ** pSeg: ** The segment to iterate through. ** ** iLeafPgno: ** Current leaf page number within segment. ** ** iLeafOffset: ** Byte offset within the current leaf that is the first byte of the ** position list data (one byte passed the position-list size field). ** ** pLeaf: ** Buffer containing current leaf page data. Set to NULL at EOF. ** ** iTermLeafPgno, iTermLeafOffset: ** Leaf page number containing the last term read from the segment. And ** the offset immediately following the term data. ** ** flags: ** Mask of FTS5_SEGITER_XXX values. Interpreted as follows: ** ** FTS5_SEGITER_ONETERM: ** If set, set the iterator to point to EOF after the current doclist ** has been exhausted. Do not proceed to the next term in the segment. ** ** FTS5_SEGITER_REVERSE: ** This flag is only ever set if FTS5_SEGITER_ONETERM is also set. If ** it is set, iterate through rowid in descending order instead of the ** default ascending order. ** ** iRowidOffset/nRowidOffset/aRowidOffset: ** These are used if the FTS5_SEGITER_REVERSE flag is set. ** ** For each rowid on the page corresponding to the current term, the ** corresponding aRowidOffset[] entry is set to the byte offset of the ** start of the "position-list-size" field within the page. ** ** iTermIdx: ** Index of current term on iTermLeafPgno. ** ** apTombstone/nTombstone: ** These are used for contentless_delete=1 tables only. When the cursor ** is first allocated, the apTombstone[] array is allocated so that it ** is large enough for all tombstones hash pages associated with the ** segment. The pages themselves are loaded lazily from the database as ** they are required.

type TFts5SegWriter

type TFts5SegWriter = struct {
	FiSegid               int32
	Fwriter               TFts5PageWriter
	FiPrevRowid           Ti64
	FbFirstRowidInDoclist Tu8
	FbFirstRowidInPage    Tu8
	FbFirstTermInPage     Tu8
	FnLeafWritten         int32
	FnEmpty               int32
	FnDlidx               int32
	FaDlidx               uintptr
	Fbtterm               TFts5Buffer
	FiBtPage              int32
}

type TFts5SegWriter1

type TFts5SegWriter1 = struct {
	FiSegid               int32
	Fwriter               TFts5PageWriter
	FiPrevRowid           Ti64
	FbFirstRowidInDoclist Tu8
	FbFirstRowidInPage    Tu8
	FbFirstTermInPage     Tu8
	FnLeafWritten         int32
	FnEmpty               int32
	FnDlidx               int32
	FaDlidx               uintptr
	Fbtterm               TFts5Buffer
	FiBtPage              int32
}

type TFts5Sorter

type TFts5Sorter = struct {
	FpStmt    uintptr
	FiRowid   Ti64
	FaPoslist uintptr
	FnIdx     int32
	FaIdx     [1]int32
}

type TFts5Sorter1

type TFts5Sorter1 = struct {
	FpStmt    uintptr
	FiRowid   Ti64
	FaPoslist uintptr
	FnIdx     int32
	FaIdx     [1]int32
}

** pStmt: ** SELECT rowid, <fts> FROM <fts> ORDER BY +rank; ** ** aIdx[]: ** There is one entry in the aIdx[] array for each phrase in the query, ** the value of which is the offset within aPoslist[] following the last ** byte of the position list for the corresponding phrase.

type TFts5Storage

type TFts5Storage = struct {
	FpConfig      uintptr
	FpIndex       uintptr
	FbTotalsValid int32
	FnTotalRow    Ti64
	FaTotalSize   uintptr
	FaStmt        [11]uintptr
}

type TFts5Storage1

type TFts5Storage1 = struct {
	FpConfig      uintptr
	FpIndex       uintptr
	FbTotalsValid int32
	FnTotalRow    Ti64
	FaTotalSize   uintptr
	FaStmt        [11]uintptr
}

type TFts5Structure

type TFts5Structure = struct {
	FnRef          int32
	FnWriteCounter Tu64
	FnOriginCntr   Tu64
	FnSegment      int32
	FnLevel        int32
	FaLevel        [1]TFts5StructureLevel
}

type TFts5Structure1

type TFts5Structure1 = struct {
	FnRef          int32
	FnWriteCounter Tu64
	FnOriginCntr   Tu64
	FnSegment      int32
	FnLevel        int32
	FaLevel        [1]TFts5StructureLevel
}

type TFts5StructureLevel

type TFts5StructureLevel = struct {
	FnMerge int32
	FnSeg   int32
	FaSeg   uintptr
}

type TFts5StructureLevel1

type TFts5StructureLevel1 = struct {
	FnMerge int32
	FnSeg   int32
	FaSeg   uintptr
}

type TFts5StructureSegment

type TFts5StructureSegment = struct {
	FiSegid          int32
	FpgnoFirst       int32
	FpgnoLast        int32
	FiOrigin1        Tu64
	FiOrigin2        Tu64
	FnPgTombstone    int32
	FnEntryTombstone Tu64
	FnEntry          Tu64
}

type TFts5StructureSegment1

type TFts5StructureSegment1 = struct {
	FiSegid          int32
	FpgnoFirst       int32
	FpgnoLast        int32
	FiOrigin1        Tu64
	FiOrigin2        Tu64
	FnPgTombstone    int32
	FnEntryTombstone Tu64
	FnEntry          Tu64
}

** The contents of the "structure" record for each index are represented ** using an Fts5Structure record in memory. Which uses instances of the ** other Fts5StructureXXX types as components. ** ** nOriginCntr: ** This value is set to non-zero for structure records created for ** contentlessdelete=1 tables only. In that case it represents the ** origin value to apply to the next top-level segment created.

type TFts5Table

type TFts5Table = struct {
	Fbase    Tsqlite3_vtab
	FpConfig uintptr
	FpIndex  uintptr
}

C documentation

/*
** Virtual-table object.
*/

type TFts5Table1

type TFts5Table1 = struct {
	Fbase    Tsqlite3_vtab
	FpConfig uintptr
	FpIndex  uintptr
}

type TFts5Termset

type TFts5Termset = struct {
	FapHash [512]uintptr
}

C documentation

/* Bucket of terms object used by the integrity-check in offsets=0 mode. */

type TFts5Termset1

type TFts5Termset1 = struct {
	FapHash [512]uintptr
}

type TFts5TermsetEntry

type TFts5TermsetEntry = struct {
	FpTerm uintptr
	FnTerm int32
	FiIdx  int32
	FpNext uintptr
}

C documentation

/*************************************************************************
*/

type TFts5TermsetEntry1

type TFts5TermsetEntry1 = struct {
	FpTerm uintptr
	FnTerm int32
	FiIdx  int32
	FpNext uintptr
}

type TFts5Token

type TFts5Token = struct {
	Fp uintptr
	Fn int32
}

type TFts5Token1

type TFts5Token1 = struct {
	Fp uintptr
	Fn int32
}

type TFts5TokenDataIter

type TFts5TokenDataIter = struct {
	FnIter          int32
	FnIterAlloc     int32
	FnMap           int32
	FnMapAlloc      int32
	FaMap           uintptr
	FaPoslistReader uintptr
	FaPoslistToIter uintptr
	FapIter         [1]uintptr
}

type TFts5TokenDataIter1

type TFts5TokenDataIter1 = struct {
	FnIter          int32
	FnIterAlloc     int32
	FnMap           int32
	FnMapAlloc      int32
	FaMap           uintptr
	FaPoslistReader uintptr
	FaPoslistToIter uintptr
	FapIter         [1]uintptr
}

** An object used to supplement Fts5Iter for tokendata=1 iterators.

type TFts5TokenDataMap

type TFts5TokenDataMap = struct {
	FiRowid Ti64
	FiPos   Ti64
	FiIter  int32
}

type TFts5TokenDataMap1

type TFts5TokenDataMap1 = struct {
	FiRowid Ti64
	FiPos   Ti64
	FiIter  int32
}

** Usually, a tokendata=1 iterator (struct Fts5TokenDataIter) accumulates an ** array of these for each row it visits. Or, for an iterator used by an ** "ORDER BY rank" query, it accumulates an array of these for the entire ** query. ** ** Each instance in the array indicates the iterator (and therefore term) ** associated with position iPos of rowid iRowid. This is used by the ** xInstToken() API.

type TFts5TokenizerModule

type TFts5TokenizerModule = struct {
	FzName     uintptr
	FpUserData uintptr
	Fx         Tfts5_tokenizer
	FxDestroy  uintptr
	FpNext     uintptr
}

type TFts5TokenizerModule1

type TFts5TokenizerModule1 = struct {
	FzName     uintptr
	FpUserData uintptr
	Fx         Tfts5_tokenizer
	FxDestroy  uintptr
	FpNext     uintptr
}

** Each tokenizer module registered with the FTS5 module is represented ** by an object of the following type. All such objects are stored as part ** of the Fts5Global.pTok list.

type TFts5TombstoneArray

type TFts5TombstoneArray = struct {
	FnRef        int32
	FnTombstone  int32
	FapTombstone [1]uintptr
}

type TFts5TombstoneArray1

type TFts5TombstoneArray1 = struct {
	FnRef        int32
	FnTombstone  int32
	FapTombstone [1]uintptr
}

** Array of tombstone pages. Reference counted.

type TFts5TransactionState

type TFts5TransactionState = struct {
	FeState     int32
	FiSavepoint int32
}

** NOTES ON TRANSACTIONS: ** ** SQLite invokes the following virtual table methods as transactions are ** opened and closed by the user: ** ** xBegin(): Start of a new transaction. ** xSync(): Initial part of two-phase commit. ** xCommit(): Final part of two-phase commit. ** xRollback(): Rollback the transaction. ** ** Anything that is required as part of a commit that may fail is performed ** in the xSync() callback. Current versions of SQLite ignore any errors ** returned by xCommit(). ** ** And as sub-transactions are opened/closed: ** ** xSavepoint(int S): Open savepoint S. ** xRelease(int S): Commit and close savepoint S. ** xRollbackTo(int S): Rollback to start of savepoint S. ** ** During a write-transaction the fts5_index.c module may cache some data ** in-memory. It is flushed to disk whenever xSync(), xRelease() or ** xSavepoint() is called. And discarded whenever xRollback() or xRollbackTo() ** is called. ** ** Additionally, if SQLITE_DEBUG is defined, an instance of the following ** structure is used to record the current transaction state. This information ** is not required, but it is used in the assert() statements executed by ** function fts5CheckTransactionState() (see below).

type TFts5VocabCursor

type TFts5VocabCursor = struct {
	Fbase     Tsqlite3_vtab_cursor
	FpStmt    uintptr
	FpFts5    uintptr
	FbEof     int32
	FpIter    uintptr
	FpStruct  uintptr
	FnLeTerm  int32
	FzLeTerm  uintptr
	FiCol     int32
	FaCnt     uintptr
	FaDoc     uintptr
	Frowid    Ti64
	Fterm     TFts5Buffer
	FiInstPos Ti64
	FiInstOff int32
}

type TFts5VocabCursor1

type TFts5VocabCursor1 = struct {
	Fbase     Tsqlite3_vtab_cursor
	FpStmt    uintptr
	FpFts5    uintptr
	FbEof     int32
	FpIter    uintptr
	FpStruct  uintptr
	FnLeTerm  int32
	FzLeTerm  uintptr
	FiCol     int32
	FaCnt     uintptr
	FaDoc     uintptr
	Frowid    Ti64
	Fterm     TFts5Buffer
	FiInstPos Ti64
	FiInstOff int32
}

type TFts5VocabTable

type TFts5VocabTable = struct {
	Fbase     Tsqlite3_vtab
	FzFts5Tbl uintptr
	FzFts5Db  uintptr
	Fdb       uintptr
	FpGlobal  uintptr
	FeType    int32
	FbBusy    uint32
}

type TFts5VocabTable1

type TFts5VocabTable1 = struct {
	Fbase     Tsqlite3_vtab
	FzFts5Tbl uintptr
	FzFts5Db  uintptr
	Fdb       uintptr
	FpGlobal  uintptr
	FeType    int32
	FbBusy    uint32
}

type TFuncDef

type TFuncDef = struct {
	FnArg      Ti8
	FfuncFlags Tu32
	FpUserData uintptr
	FpNext     uintptr
	FxSFunc    uintptr
	FxFinalize uintptr
	FxValue    uintptr
	FxInverse  uintptr
	FzName     uintptr
	Fu         struct {
		FpDestructor [0]uintptr
		FpHash       uintptr
	}
}

type TFuncDef1

type TFuncDef1 = struct {
	FnArg      Ti8
	FfuncFlags Tu32
	FpUserData uintptr
	FpNext     uintptr
	FxSFunc    uintptr
	FxFinalize uintptr
	FxValue    uintptr
	FxInverse  uintptr
	FzName     uintptr
	Fu         struct {
		FpDestructor [0]uintptr
		FpHash       uintptr
	}
}

** Each SQL function is defined by an instance of the following ** structure. For global built-in functions (ex: substr(), max(), count()) ** a pointer to this structure is held in the sqlite3BuiltinFunctions object. ** For per-connection application-defined functions, a pointer to this ** structure is held in the db->aHash hash table. ** ** The u.pHash field is used by the global built-ins. The u.pDestructor ** field is used by per-connection app-def functions.

type TFuncDefHash

type TFuncDefHash = struct {
	Fa [23]uintptr
}

type TFuncDefHash1

type TFuncDefHash1 = struct {
	Fa [23]uintptr
}

** A hash table for built-in function definitions. (Application-defined ** functions use a regular table table from hash.h.) ** ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. ** Collisions are on the FuncDef.u.pHash chain. Use the SQLITE_FUNC_HASH() ** macro to compute a hash on the function name.

type TFuncDestructor

type TFuncDestructor = struct {
	FnRef      int32
	FxDestroy  uintptr
	FpUserData uintptr
}

type TFuncDestructor1

type TFuncDestructor1 = struct {
	FnRef      int32
	FxDestroy  uintptr
	FpUserData uintptr
}

** This structure encapsulates a user-function destructor callback (as ** configured using create_function_v2()) and a reference counter. When ** create_function_v2() is called to create a function with a destructor, ** a single object of this type is allocated. FuncDestructor.nRef is set to ** the number of FuncDef objects created (either 1 or 3, depending on whether ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor ** member of each of the new FuncDef objects is set to point to the allocated ** FuncDestructor. ** ** Thereafter, when one of the FuncDef objects is deleted, the reference ** count on this object is decremented. When it reaches 0, the destructor ** is invoked and the FuncDestructor structure freed.

type TGeoBBox

type TGeoBBox = struct {
	FisInit int32
	Fa      [4]TRtreeCoord
}

C documentation

/*
** State vector for the geopoly_group_bbox() aggregate function.
*/

type TGeoBBox1

type TGeoBBox1 = struct {
	FisInit int32
	Fa      [4]TRtreeCoord
}

type TGeoCoord

type TGeoCoord = float32

C documentation

/* Datatype for coordinates
*/

type TGeoEvent

type TGeoEvent = struct {
	Fx     float64
	FeType int32
	FpSeg  uintptr
	FpNext uintptr
}

C documentation

/* Objects used by the overlap algorihm. */

type TGeoEvent1

type TGeoEvent1 = struct {
	Fx     float64
	FeType int32
	FpSeg  uintptr
	FpNext uintptr
}

type TGeoOverlap

type TGeoOverlap = struct {
	FaEvent   uintptr
	FaSegment uintptr
	FnEvent   int32
	FnSegment int32
}

type TGeoOverlap1

type TGeoOverlap1 = struct {
	FaEvent   uintptr
	FaSegment uintptr
	FnEvent   int32
	FnSegment int32
}

type TGeoParse

type TGeoParse = struct {
	Fz       uintptr
	FnVertex int32
	FnAlloc  int32
	FnErr    int32
	Fa       uintptr
}

C documentation

/*
** State of a parse of a GeoJSON input.
*/

type TGeoParse1

type TGeoParse1 = struct {
	Fz       uintptr
	FnVertex int32
	FnAlloc  int32
	FnErr    int32
	Fa       uintptr
}

type TGeoPoly

type TGeoPoly = struct {
	FnVertex int32
	Fhdr     [4]uint8
	Fa       [8]TGeoCoord
}

C documentation

/*
** Internal representation of a polygon.
**
** The polygon consists of a sequence of vertexes.  There is a line
** segment between each pair of vertexes, and one final segment from
** the last vertex back to the first.  (This differs from the GeoJSON
** standard in which the final vertex is a repeat of the first.)
**
** The polygon follows the right-hand rule.  The area to the right of
** each segment is "outside" and the area to the left is "inside".
**
** The on-disk representation consists of a 4-byte header followed by
** the values.  The 4-byte header is:
**
**      encoding    (1 byte)   0=big-endian, 1=little-endian
**      nvertex     (3 bytes)  Number of vertexes as a big-endian integer
**
** Enough space is allocated for 4 coordinates, to work around over-zealous
** warnings coming from some compiler (notably, clang). In reality, the size
** of each GeoPoly memory allocate is adjusted as necessary so that the
** GeoPoly.a[] array at the end is the appropriate size.
*/

type TGeoPoly1

type TGeoPoly1 = struct {
	FnVertex int32
	Fhdr     [4]uint8
	Fa       [8]TGeoCoord
}

type TGeoSegment

type TGeoSegment = struct {
	FC     float64
	FB     float64
	Fy     float64
	Fy0    float32
	Fside  uint8
	Fidx   uint32
	FpNext uintptr
}

type TGeoSegment1

type TGeoSegment1 = struct {
	FC     float64
	FB     float64
	Fy     float64
	Fy0    float32
	Fside  uint8
	Fidx   uint32
	FpNext uintptr
}

type TGroupConcatCtx

type TGroupConcatCtx = struct {
	Fstr             TStrAccum
	FnAccum          int32
	FnFirstSepLength int32
	FpnSepLengths    uintptr
}

C documentation

/*
** group_concat(EXPR, ?SEPARATOR?)
** string_agg(EXPR, SEPARATOR)
**
** The SEPARATOR goes before the EXPR string.  This is tragic.  The
** groupConcatInverse() implementation would have been easier if the
** SEPARATOR were appended after EXPR.  And the order is undocumented,
** so we could change it, in theory.  But the old behavior has been
** around for so long that we dare not, for fear of breaking something.
*/

type THash

type THash = struct {
	Fhtsize uint32
	Fcount  uint32
	Ffirst  uintptr
	Fht     uintptr
}

C documentation

/* Forward declarations of structures. */

type THash1

type THash1 = struct {
	Fhtsize uint32
	Fcount  uint32
	Ffirst  uintptr
	Fht     uintptr
}

A complete hash table is an instance of the following structure.

** The internals of this structure are intended to be opaque -- client ** code should not attempt to access or modify the fields of this structure ** directly. Change this structure only by using the routines below. ** However, some of the "procedures" and "functions" for modifying and ** accessing this structure are really macros, so we can't really make ** this structure opaque. ** ** All elements of the hash table are on a single doubly-linked list. ** Hash.first points to the head of this list. ** ** There are Hash.htsize buckets. Each bucket points to a spot in ** the global doubly-linked list. The contents of the bucket are the ** element pointed to plus the next _ht.count-1 elements in the list. ** ** Hash.htsize and Hash.ht may be zero. In that case lookup is done ** by a linear search of the global list. For small tables, the ** Hash.ht table is never allocated because if there are few elements ** in the table, it is faster to do a linear search than to manage ** the hash table.

type THashElem

type THashElem = struct {
	Fnext uintptr
	Fprev uintptr
	Fdata uintptr
	FpKey uintptr
}

type THashElem1

type THashElem1 = struct {
	Fnext uintptr
	Fprev uintptr
	Fdata uintptr
	FpKey uintptr
}

Each element in the hash table is an instance of the following

** structure. All elements are stored on a single doubly-linked list. ** ** Again, this structure is intended to be opaque, but it can't really ** be opaque because it is used by macros.

type THiddenIndexInfo

type THiddenIndexInfo = struct {
	FpWC       uintptr
	FpParse    uintptr
	FeDistinct int32
	FmIn       Tu32
	FmHandleIn Tu32
	FaRhs      [1]uintptr
}

C documentation

/*
** Extra information appended to the end of sqlite3_index_info but not
** visible to the xBestIndex function, at least not directly.  The
** sqlite3_vtab_collation() interface knows how to reach it, however.
**
** This object is not an API and can be changed from one release to the
** next.  As long as allocateIndexInfo() and sqlite3_vtab_collation()
** agree on the structure, all will be well.
*/

type THiddenIndexInfo1

type THiddenIndexInfo1 = struct {
	FpWC       uintptr
	FpParse    uintptr
	FeDistinct int32
	FmIn       Tu32
	FmHandleIn Tu32
	FaRhs      [1]uintptr
}

type THighlightContext

type THighlightContext = struct {
	FiRangeStart int32
	FiRangeEnd   int32
	FzOpen       uintptr
	FzClose      uintptr
	FzIn         uintptr
	FnIn         int32
	Fiter        TCInstIter
	FiPos        int32
	FiOff        int32
	FbOpen       int32
	FzOut        uintptr
}

C documentation

/*************************************************************************
** Start of highlight() implementation.
*/

type THighlightContext1

type THighlightContext1 = struct {
	FiRangeStart int32
	FiRangeEnd   int32
	FzOpen       uintptr
	FzClose      uintptr
	FzIn         uintptr
	FnIn         int32
	Fiter        TCInstIter
	FiPos        int32
	FiOff        int32
	FbOpen       int32
	FzOut        uintptr
}

type TIdList

type TIdList = struct {
	FnId int32
	FeU4 Tu8
	Fa   [1]TIdList_item
}

type TIdList1

type TIdList1 = struct {
	FnId int32
	FeU4 Tu8
	Fa   [1]TIdList_item
}

** An instance of this structure can hold a simple list of identifiers, ** such as the list "a,b,c" in the following statements: ** ** INSERT INTO t(a,b,c) VALUES ...; ** CREATE INDEX idx ON t(a,b,c); ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; ** ** The IdList.a.idx field is used when the IdList represents the list of ** column names after a table name in an INSERT statement. In the statement ** ** INSERT INTO t(a,b,c) ... ** ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.

type TIdList_item

type TIdList_item = struct {
	FzName uintptr
	Fu4    struct {
		FpExpr       [0]uintptr
		Fidx         int32
		F__ccgo_pad2 [4]byte
	}
}

type TIdxCover

type TIdxCover = struct {
	FpIdx uintptr
	FiCur int32
}

** An instance of the following structure is used by the tree walker ** to determine if an expression can be evaluated by reference to the ** index only, without having to do a search for the corresponding ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur ** is the cursor for the table.

type TInLoop

type TInLoop = struct {
	FiCur       int32
	FaddrInTop  int32
	FiBase      int32
	FnPrefix    int32
	FeEndLoopOp Tu8
}

type TIncrMerger

type TIncrMerger = struct {
	FpTask      uintptr
	FpMerger    uintptr
	FiStartOff  Ti64
	FmxSz       int32
	FbEof       int32
	FbUseThread int32
	FaFile      [2]TSorterFile
}

In-memory list of records

type TIncrMerger1

type TIncrMerger1 = struct {
	FpTask      uintptr
	FpMerger    uintptr
	FiStartOff  Ti64
	FmxSz       int32
	FbEof       int32
	FbUseThread int32
	FaFile      [2]TSorterFile
}

** Normally, a PmaReader object iterates through an existing PMA stored ** within a temp file. However, if the PmaReader.pIncr variable points to ** an object of the following type, it may be used to iterate/merge through ** multiple PMAs simultaneously. ** ** There are two types of IncrMerger object - single (bUseThread==0) and ** multi-threaded (bUseThread==1). ** ** A multi-threaded IncrMerger object uses two temporary files - aFile[0] ** and aFile[1]. Neither file is allowed to grow to more than mxSz bytes in ** size. When the IncrMerger is initialized, it reads enough data from ** pMerger to populate aFile[0]. It then sets variables within the ** corresponding PmaReader object to read from that file and kicks off ** a background thread to populate aFile[1] with the next mxSz bytes of ** sorted record data from pMerger. ** ** When the PmaReader reaches the end of aFile[0], it blocks until the ** background thread has finished populating aFile[1]. It then exchanges ** the contents of the aFile[0] and aFile[1] variables within this structure, ** sets the PmaReader fields to read from the new aFile[0] and kicks off ** another background thread to populate the new aFile[1]. And so on, until ** the contents of pMerger are exhausted. ** ** A single-threaded IncrMerger does not open any temporary files of its ** own. Instead, it has exclusive access to mxSz bytes of space beginning ** at offset iStartOff of file pTask->file2. And instead of using a ** background thread to prepare data for the PmaReader, with a single ** threaded IncrMerger the allocate part of pTask->file2 is "refilled" with ** keys from pMerger by the calling thread whenever the PmaReader runs out ** of data.

type TIncrblob

type TIncrblob = struct {
	FnByte   int32
	FiOffset int32
	FiCol    Tu16
	FpCsr    uintptr
	FpStmt   uintptr
	Fdb      uintptr
	FzDb     uintptr
	FpTab    uintptr
}

C documentation

/*
** Valid sqlite3_blob* handles point to Incrblob structures.
*/

type TIncrblob1

type TIncrblob1 = struct {
	FnByte   int32
	FiOffset int32
	FiCol    Tu16
	FpCsr    uintptr
	FpStmt   uintptr
	Fdb      uintptr
	FzDb     uintptr
	FpTab    uintptr
}

type TIndex

type TIndex = struct {
	FzName         uintptr
	FaiColumn      uintptr
	FaiRowLogEst   uintptr
	FpTable        uintptr
	FzColAff       uintptr
	FpNext         uintptr
	FpSchema       uintptr
	FaSortOrder    uintptr
	FazColl        uintptr
	FpPartIdxWhere uintptr
	FaColExpr      uintptr
	Ftnum          TPgno
	FszIdxRow      TLogEst
	FnKeyCol       Tu16
	FnColumn       Tu16
	FonError       Tu8
	F__ccgo100     uint16
	FnSample       int32
	FmxSample      int32
	FnSampleCol    int32
	FaAvgEq        uintptr
	FaSample       uintptr
	FaiRowEst      uintptr
	FnRowEst0      TtRowcnt
	FcolNotIdxed   TBitmask
}

type TIndex1

type TIndex1 = struct {
	FzName         uintptr
	FaiColumn      uintptr
	FaiRowLogEst   uintptr
	FpTable        uintptr
	FzColAff       uintptr
	FpNext         uintptr
	FpSchema       uintptr
	FaSortOrder    uintptr
	FazColl        uintptr
	FpPartIdxWhere uintptr
	FaColExpr      uintptr
	Ftnum          TPgno
	FszIdxRow      TLogEst
	FnKeyCol       Tu16
	FnColumn       Tu16
	FonError       Tu8
	F__ccgo100     uint16
	FnSample       int32
	FmxSample      int32
	FnSampleCol    int32
	FaAvgEq        uintptr
	FaSample       uintptr
	FaiRowEst      uintptr
	FnRowEst0      TtRowcnt
	FcolNotIdxed   TBitmask
}

** Each SQL index is represented in memory by an ** instance of the following structure. ** ** The columns of the table that are to be indexed are described ** by the aiColumn[] field of this structure. For example, suppose ** we have the following table and index: ** ** CREATE TABLE Ex1(c1 int, c2 int, c3 text); ** CREATE INDEX Ex2 ON Ex1(c3,c1); ** ** In the Table structure describing Ex1, nCol==3 because there are ** three columns in the table. In the Index structure describing ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. ** The second column to be indexed (c1) has an index of 0 in ** Ex1.aCol[], hence Ex2.aiColumn[1]==0. ** ** The Index.onError field determines whether or not the indexed columns ** must be unique and what to do if they are not. When Index.onError=OE_None, ** it means this is not a unique index. Otherwise it is a unique index ** and the value of Index.onError indicates which conflict resolution ** algorithm to employ when an attempt is made to insert a non-unique ** element. ** ** The colNotIdxed bitmask is used in combination with SrcItem.colUsed ** for a fast test to see if an index can serve as a covering index. ** colNotIdxed has a 1 bit for every column of the original table that ** is *not* available in the index. Thus the expression ** "colUsed & colNotIdxed" will be non-zero if the index is not a ** covering index. The most significant bit of of colNotIdxed will always ** be true (note-20221022-a). If a column beyond the 63rd column of the ** table is used, the "colUsed & colNotIdxed" test will always be non-zero ** and we have to assume either that the index is not covering, or use ** an alternative (slower) algorithm to determine whether or not ** the index is covering. ** ** While parsing a CREATE TABLE or CREATE INDEX statement in order to ** generate VDBE code (as opposed to parsing one read from an sqlite_schema ** table as part of parsing an existing database schema), transient instances ** of this structure may be created. In this case the Index.tnum variable is ** used to store the address of a VDBE instruction, not a database page ** number (it cannot - the database page is not allocated until the VDBE ** program is executed). See convertToWithoutRowidTable() for details.

type TIndexIterator

type TIndexIterator = struct {
	FeType int32
	Fi     int32
	Fu     struct {
		Fax [0]struct {
			FnIdx int32
			FaIdx uintptr
		}
		Flx struct {
			FpIdx uintptr
		}
		F__ccgo_pad2 [8]byte
	}
}

type TIndexIterator1

type TIndexIterator1 = struct {
	FeType int32
	Fi     int32
	Fu     struct {
		Fax [0]struct {
			FnIdx int32
			FaIdx uintptr
		}
		Flx struct {
			FpIdx uintptr
		}
		F__ccgo_pad2 [8]byte
	}
}

type TIndexListTerm

type TIndexListTerm = struct {
	Fp  uintptr
	Fix int32
}

C documentation

/*
** The sqlite3GenerateConstraintChecks() routine usually wants to visit
** the indexes of a table in the order provided in the Table->pIndex list.
** However, sometimes (rarely - when there is an upsert) it wants to visit
** the indexes in a different order.  The following data structures accomplish
** this.
**
** The IndexIterator object is used to walk through all of the indexes
** of a table in either Index.pNext order, or in some other order established
** by an array of IndexListTerm objects.
*/

type TIndexListTerm1

type TIndexListTerm1 = struct {
	Fp  uintptr
	Fix int32
}

When IndexIterator.eType==1, then each index is an array of instances

** of the following object

type TIndexSample

type TIndexSample = struct {
	Fp     uintptr
	Fn     int32
	FanEq  uintptr
	FanLt  uintptr
	FanDLt uintptr
}

type TIndexSample1

type TIndexSample1 = struct {
	Fp     uintptr
	Fn     int32
	FanEq  uintptr
	FanLt  uintptr
	FanDLt uintptr
}

** Each sample stored in the sqlite_stat4 table is represented in memory ** using a structure of this type. See documentation at the top of the ** analyze.c source file for additional information.

type TIndexedExpr

type TIndexedExpr = struct {
	FpExpr         uintptr
	FiDataCur      int32
	FiIdxCur       int32
	FiIdxCol       int32
	FbMaybeNullRow Tu8
	Faff           Tu8
	FpIENext       uintptr
}

type TIndexedExpr1

type TIndexedExpr1 = struct {
	FpExpr         uintptr
	FiDataCur      int32
	FiIdxCur       int32
	FiIdxCol       int32
	FbMaybeNullRow Tu8
	Faff           Tu8
	FpIENext       uintptr
}

** For each index X that has as one of its arguments either an expression ** or the name of a virtual generated column, and if X is in scope such that ** the value of the expression can simply be read from the index, then ** there is an instance of this object on the Parse.pIdxExpr list. ** ** During code generation, while generating code to evaluate expressions, ** this list is consulted and if a matching expression is found, the value ** is read from the index rather than being recomputed.

type TInitData

type TInitData = struct {
	Fdb         uintptr
	FpzErrMsg   uintptr
	FiDb        int32
	Frc         int32
	FmInitFlags Tu32
	FnInitRow   Tu32
	FmxPage     TPgno
}

C documentation

/*
** A pointer to this structure is used to communicate information
** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
*/

type TIntegrityCk

type TIntegrityCk = struct {
	FpBt     uintptr
	FpPager  uintptr
	FaPgRef  uintptr
	FnCkPage TPgno
	FmxErr   int32
	FnErr    int32
	Frc      int32
	FnStep   Tu32
	FzPfx    uintptr
	Fv0      TPgno
	Fv1      TPgno
	Fv2      int32
	FerrMsg  TStrAccum
	Fheap    uintptr
	Fdb      uintptr
	FnRow    Ti64
}

C documentation

/*
** This structure is passed around through all the PRAGMA integrity_check
** checking routines in order to keep track of some global state information.
**
** The aRef[] array is allocated so that there is 1 bit for each page in
** the database. As the integrity-check proceeds, for each page used in
** the database the corresponding bit is set. This allows integrity-check to
** detect pages that are used twice and orphaned pages (both of which
** indicate corruption).
*/

type TIntegrityCk1

type TIntegrityCk1 = struct {
	FpBt     uintptr
	FpPager  uintptr
	FaPgRef  uintptr
	FnCkPage TPgno
	FmxErr   int32
	FnErr    int32
	Frc      int32
	FnStep   Tu32
	FzPfx    uintptr
	Fv0      TPgno
	Fv1      TPgno
	Fv2      int32
	FerrMsg  TStrAccum
	Fheap    uintptr
	Fdb      uintptr
	FnRow    Ti64
}

type TJsonCache

type TJsonCache = struct {
	Fdb    uintptr
	FnUsed int32
	Fa     [4]uintptr
}

C documentation

/* Objects */

type TJsonCache1

type TJsonCache1 = struct {
	Fdb    uintptr
	FnUsed int32
	Fa     [4]uintptr
}

A cache mapping JSON text into JSONB blobs.

** ** Each cache entry is a JsonParse object with the following restrictions: ** ** * The bReadOnly flag must be set ** ** * The aBlob[] array must be owned by the JsonParse object. In other ** words, nBlobAlloc must be non-zero. ** ** * eEdit and delta must be zero. ** ** * zJson must be an RCStr. In other words bJsonIsRCStr must be true.

type TJsonEachConnection

type TJsonEachConnection = struct {
	Fbase Tsqlite3_vtab
	Fdb   uintptr
}

type TJsonEachConnection1

type TJsonEachConnection1 = struct {
	Fbase Tsqlite3_vtab
	Fdb   uintptr
}

type TJsonEachCursor

type TJsonEachCursor = struct {
	Fbase         Tsqlite3_vtab_cursor
	FiRowid       Tu32
	Fi            Tu32
	FiEnd         Tu32
	FnRoot        Tu32
	FeType        Tu8
	FbRecursive   Tu8
	FnParent      Tu32
	FnParentAlloc Tu32
	FaParent      uintptr
	Fdb           uintptr
	Fpath         TJsonString
	FsParse       TJsonParse
}

type TJsonEachCursor1

type TJsonEachCursor1 = struct {
	Fbase         Tsqlite3_vtab_cursor
	FiRowid       Tu32
	Fi            Tu32
	FiEnd         Tu32
	FnRoot        Tu32
	FeType        Tu8
	FbRecursive   Tu8
	FnParent      Tu32
	FnParentAlloc Tu32
	FaParent      uintptr
	Fdb           uintptr
	Fpath         TJsonString
	FsParse       TJsonParse
}

type TJsonParent

type TJsonParent = struct {
	FiHead  Tu32
	FiValue Tu32
	FiEnd   Tu32
	FnPath  Tu32
	FiKey   Ti64
}

C documentation

/****************************************************************************
** The json_each virtual table
****************************************************************************/

type TJsonParent1

type TJsonParent1 = struct {
	FiHead  Tu32
	FiValue Tu32
	FiEnd   Tu32
	FnPath  Tu32
	FiKey   Ti64
}

type TJsonParse

type TJsonParse = struct {
	FaBlob        uintptr
	FnBlob        Tu32
	FnBlobAlloc   Tu32
	FzJson        uintptr
	Fdb           uintptr
	FnJson        int32
	FnJPRef       Tu32
	FiErr         Tu32
	FiDepth       Tu16
	FnErr         Tu8
	Foom          Tu8
	FbJsonIsRCStr Tu8
	FhasNonstd    Tu8
	FbReadOnly    Tu8
	FeEdit        Tu8
	Fdelta        int32
	FnIns         Tu32
	FiLabel       Tu32
	FaIns         uintptr
}

type TJsonParse1

type TJsonParse1 = struct {
	FaBlob        uintptr
	FnBlob        Tu32
	FnBlobAlloc   Tu32
	FzJson        uintptr
	Fdb           uintptr
	FnJson        int32
	FnJPRef       Tu32
	FiErr         Tu32
	FiDepth       Tu16
	FnErr         Tu8
	Foom          Tu8
	FbJsonIsRCStr Tu8
	FhasNonstd    Tu8
	FbReadOnly    Tu8
	FeEdit        Tu8
	Fdelta        int32
	FnIns         Tu32
	FiLabel       Tu32
	FaIns         uintptr
}

A parsed JSON value.  Lifecycle:

** ** 1. JSON comes in and is parsed into a JSONB value in aBlob. The ** original text is stored in zJson. This step is skipped if the ** input is JSONB instead of text JSON. ** ** 2. The aBlob[] array is searched using the JSON path notation, if needed. ** ** 3. Zero or more changes are made to aBlob[] (via json_remove() or ** json_replace() or json_patch() or similar). ** ** 4. New JSON text is generated from the aBlob[] for output. This step ** is skipped if the function is one of the jsonb_* functions that ** returns JSONB instead of text JSON.

type TJsonPretty

type TJsonPretty = struct {
	FpParse   uintptr
	FpOut     uintptr
	FzIndent  uintptr
	FszIndent Tu32
	FnIndent  Tu32
}

C documentation

/* Context for recursion of json_pretty()
*/

type TJsonPretty1

type TJsonPretty1 = struct {
	FpParse   uintptr
	FpOut     uintptr
	FzIndent  uintptr
	FszIndent Tu32
	FnIndent  Tu32
}

type TJsonString

type TJsonString = struct {
	FpCtx    uintptr
	FzBuf    uintptr
	FnAlloc  Tu64
	FnUsed   Tu64
	FbStatic Tu8
	FeErr    Tu8
	FzSpace  [100]int8
}

type TJsonString1

type TJsonString1 = struct {
	FpCtx    uintptr
	FzBuf    uintptr
	FnAlloc  Tu64
	FnUsed   Tu64
	FbStatic Tu8
	FeErr    Tu8
	FzSpace  [100]int8
}

An instance of this object represents a JSON string

** under construction. Really, this is a generic string accumulator ** that can be and is used to create strings other than JSON. ** ** If the generated string is longer than will fit into the zSpace[] buffer, ** then it will be an RCStr string. This aids with caching of large ** JSON strings.

type TKeyInfo

type TKeyInfo = struct {
	FnRef       Tu32
	Fenc        Tu8
	FnKeyField  Tu16
	FnAllField  Tu16
	Fdb         uintptr
	FaSortFlags uintptr
	FaColl      [1]uintptr
}

type TKeyInfo1

type TKeyInfo1 = struct {
	FnRef       Tu32
	Fenc        Tu8
	FnKeyField  Tu16
	FnAllField  Tu16
	Fdb         uintptr
	FaSortFlags uintptr
	FaColl      [1]uintptr
}

** An instance of the following structure is passed as the first ** argument to sqlite3VdbeKeyCompare and is used to control the ** comparison of the two index keys. ** ** Note that aSortOrder[] and aColl[] have nField+1 slots. There ** are nField slots for the columns of an index then one extra slot ** for the rowid at the end.

type TLastValueCtx

type TLastValueCtx = struct {
	FpVal uintptr
	FnVal int32
}

** Context object for last_value() window function.

type TLogEst

type TLogEst = int16

C documentation

/*
** Estimated quantities used for query planning are stored as 16-bit
** logarithms.  For quantity X, the value stored is 10*log2(X).  This
** gives a possible range of values of approximately 1.0e986 to 1e-986.
** But the allowed values are "grainy".  Not every value is representable.
** For example, quantities 16 and 17 are both represented by a LogEst
** of 40.  However, since LogEst quantities are suppose to be estimates,
** not exact values, this imprecision is not a problem.
**
** "LogEst" is short for "Logarithmic Estimate".
**
** Examples:
**      1 -> 0              20 -> 43          10000 -> 132
**      2 -> 10             25 -> 46          25000 -> 146
**      3 -> 16            100 -> 66        1000000 -> 199
**      4 -> 20           1000 -> 99        1048576 -> 200
**     10 -> 33           1024 -> 100    4294967296 -> 320
**
** The LogEst can be negative to indicate fractional values.
** Examples:
**
**    0.5 -> -10           0.1 -> -33        0.0625 -> -40
*/

type TLookaside

type TLookaside = struct {
	FbDisable   Tu32
	Fsz         Tu16
	FszTrue     Tu16
	FbMalloced  Tu8
	FnSlot      Tu32
	FanStat     [3]Tu32
	FpInit      uintptr
	FpFree      uintptr
	FpSmallInit uintptr
	FpSmallFree uintptr
	FpMiddle    uintptr
	FpStart     uintptr
	FpEnd       uintptr
	FpTrueEnd   uintptr
}

type TLookaside1

type TLookaside1 = struct {
	FbDisable   Tu32
	Fsz         Tu16
	FszTrue     Tu16
	FbMalloced  Tu8
	FnSlot      Tu32
	FanStat     [3]Tu32
	FpInit      uintptr
	FpFree      uintptr
	FpSmallInit uintptr
	FpSmallFree uintptr
	FpMiddle    uintptr
	FpStart     uintptr
	FpEnd       uintptr
	FpTrueEnd   uintptr
}

** Lookaside malloc is a set of fixed-size buffers that can be used ** to satisfy small transient memory allocation requests for objects ** associated with a particular database connection. The use of ** lookaside malloc provides a significant performance enhancement ** (approx 10%) by avoiding numerous malloc/free requests while parsing ** SQL statements. ** ** The Lookaside structure holds configuration information about the ** lookaside malloc subsystem. Each available memory allocation in ** the lookaside subsystem is stored on a linked list of LookasideSlot ** objects. ** ** Lookaside allocations are only allowed for objects that are associated ** with a particular database connection. Hence, schema information cannot ** be stored in lookaside because in shared cache mode the schema information ** is shared by multiple database connections. Therefore, while parsing ** schema information, the Lookaside.bEnabled flag is cleared so that ** lookaside allocations are not used to construct the schema objects. ** ** New lookaside allocations are only allowed if bDisable==0. When ** bDisable is greater than zero, sz is set to zero which effectively ** disables lookaside without adding a new test for the bDisable flag ** in a performance-critical path. sz should be set by to szTrue whenever ** bDisable changes back to zero. ** ** Lookaside buffers are initially held on the pInit list. As they are ** used and freed, they are added back to the pFree list. New allocations ** come off of pFree first, then pInit as a fallback. This dual-list ** allows use to compute a high-water mark - the maximum number of allocations ** outstanding at any point in the past - by subtracting the number of ** allocations on the pInit list from the total number of allocations. ** ** Enhancement on 2019-12-12: Two-size-lookaside ** The default lookaside configuration is 100 slots of 1200 bytes each. ** The larger slot sizes are important for performance, but they waste ** a lot of space, as most lookaside allocations are less than 128 bytes. ** The two-size-lookaside enhancement breaks up the lookaside allocation ** into two pools: One of 128-byte slots and the other of the default size ** (1200-byte) slots. Allocations are filled from the small-pool first, ** failing over to the full-size pool if that does not work. Thus more ** lookaside slots are available while also using less memory. ** This enhancement can be omitted by compiling with ** SQLITE_OMIT_TWOSIZE_LOOKASIDE.

type TLookasideSlot

type TLookasideSlot = struct {
	FpNext uintptr
}

type TLookasideSlot1

type TLookasideSlot1 = struct {
	FpNext uintptr
}

type TMem

type TMem = struct {
	Fu        TMemValue
	Fz        uintptr
	Fn        int32
	Fflags    Tu16
	Fenc      Tu8
	FeSubtype Tu8
	Fdb       uintptr
	FszMalloc int32
	FuTemp    Tu32
	FzMalloc  uintptr
	FxDel     uintptr
}

C documentation

/*
** The names of the following types declared in vdbeInt.h are required
** for the VdbeOp definition.
*/

type TMem0Global

type TMem0Global = struct {
	Fmutex          uintptr
	FalarmThreshold Tsqlite3_int64
	FhardLimit      Tsqlite3_int64
	FnearlyFull     int32
}

C documentation

/*
** State information local to the memory allocation subsystem.
*/

type TMemFS

type TMemFS = struct {
	FnMemStore  int32
	FapMemStore uintptr
}

C documentation

/*
** File-scope variables for holding the memdb files that are accessible
** to multiple database connections in separate threads.
**
** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
*/

type TMemFile

type TMemFile = struct {
	Fbase   Tsqlite3_file
	FpStore uintptr
	FeLock  int32
}

type TMemFile1

type TMemFile1 = struct {
	Fbase   Tsqlite3_file
	FpStore uintptr
	FeLock  int32
}

An open file

type TMemJournal

type TMemJournal = struct {
	FpMethod    uintptr
	FnChunkSize int32
	FnSpill     int32
	FpFirst     uintptr
	Fendpoint   TFilePoint
	Freadpoint  TFilePoint
	Fflags      int32
	FpVfs       uintptr
	FzJournal   uintptr
}

C documentation

/* Forward references to internal structures */

type TMemJournal1

type TMemJournal1 = struct {
	FpMethod    uintptr
	FnChunkSize int32
	FnSpill     int32
	FpFirst     uintptr
	Fendpoint   TFilePoint
	Freadpoint  TFilePoint
	Fflags      int32
	FpVfs       uintptr
	FzJournal   uintptr
}

** This structure is a subclass of sqlite3_file. Each open memory-journal ** is an instance of this class.

type TMemPage

type TMemPage = struct {
	FisInit          Tu8
	FintKey          Tu8
	FintKeyLeaf      Tu8
	Fpgno            TPgno
	Fleaf            Tu8
	FhdrOffset       Tu8
	FchildPtrSize    Tu8
	Fmax1bytePayload Tu8
	FnOverflow       Tu8
	FmaxLocal        Tu16
	FminLocal        Tu16
	FcellOffset      Tu16
	FnFree           int32
	FnCell           Tu16
	FmaskPage        Tu16
	FaiOvfl          [4]Tu16
	FapOvfl          [4]uintptr
	FpBt             uintptr
	FaData           uintptr
	FaDataEnd        uintptr
	FaCellIdx        uintptr
	FaDataOfst       uintptr
	FpDbPage         uintptr
	FxCellSize       uintptr
	FxParseCell      uintptr
}

C documentation

/* Forward declarations */

type TMemPage1

type TMemPage1 = struct {
	FisInit          Tu8
	FintKey          Tu8
	FintKeyLeaf      Tu8
	Fpgno            TPgno
	Fleaf            Tu8
	FhdrOffset       Tu8
	FchildPtrSize    Tu8
	Fmax1bytePayload Tu8
	FnOverflow       Tu8
	FmaxLocal        Tu16
	FminLocal        Tu16
	FcellOffset      Tu16
	FnFree           int32
	FnCell           Tu16
	FmaskPage        Tu16
	FaiOvfl          [4]Tu16
	FapOvfl          [4]uintptr
	FpBt             uintptr
	FaData           uintptr
	FaDataEnd        uintptr
	FaCellIdx        uintptr
	FaDataOfst       uintptr
	FpDbPage         uintptr
	FxCellSize       uintptr
	FxParseCell      uintptr
}

** An instance of this object stores information about each a single database ** page that has been loaded into memory. The information in this object ** is derived from the raw on-disk page content. ** ** As each database page is loaded into memory, the pager allocates an ** instance of this object and zeros the first 8 bytes. (This is the ** "extra" information associated with each page of the pager.) ** ** Access to all fields of this structure is controlled by the mutex ** stored in MemPage.pBt->mutex.

type TMemStore

type TMemStore = struct {
	Fsz      Tsqlite3_int64
	FszAlloc Tsqlite3_int64
	FszMax   Tsqlite3_int64
	FaData   uintptr
	FpMutex  uintptr
	FnMmap   int32
	FmFlags  uint32
	FnRdLock int32
	FnWrLock int32
	FnRef    int32
	FzFName  uintptr
}

type TMemStore1

type TMemStore1 = struct {
	Fsz      Tsqlite3_int64
	FszAlloc Tsqlite3_int64
	FszMax   Tsqlite3_int64
	FaData   uintptr
	FpMutex  uintptr
	FnMmap   int32
	FmFlags  uint32
	FnRdLock int32
	FnWrLock int32
	FnRef    int32
	FzFName  uintptr
}

Storage for a memdb file.

** ** An memdb object can be shared or separate. Shared memdb objects can be ** used by more than one database connection. Mutexes are used by shared ** memdb objects to coordinate access. Separate memdb objects are only ** connected to a single database connection and do not require additional ** mutexes. ** ** Shared memdb objects have .zFName!=0 and .pMutex!=0. They are created ** using "file:/name?vfs=memdb". The first character of the name must be ** "/" or else the object will be a separate memdb object. All shared ** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order. ** ** Separate memdb objects are created using a name that does not begin ** with "/" or using sqlite3_deserialize(). ** ** Access rules for shared MemStore objects: ** ** * .zFName is initialized when the object is created and afterwards ** is unchanged until the object is destroyed. So it can be accessed ** at any time as long as we know the object is not being destroyed, ** which means while either the SQLITE_MUTEX_STATIC_VFS1 or ** .pMutex is held or the object is not part of memdb_g.apMemStore[]. ** ** * Can .pMutex can only be changed while holding the ** SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part ** of memdb_g.apMemStore[]. ** ** * Other fields can only be changed while holding the .pMutex mutex ** or when the .nRef is less than zero and the object is not part of ** memdb_g.apMemStore[]. ** ** * The .aData pointer has the added requirement that it can can only ** be changed (for resizing) when nMmap is zero. **

type TMemValue

type TMemValue = struct {
	Fi      [0]int64
	FnZero  [0]int32
	FzPType [0]uintptr
	FpDef   [0]uintptr
	Fr      float64
}

type TMemVfs

type TMemVfs = struct {
	FiVersion          int32
	FszOsFile          int32
	FmxPathname        int32
	FpNext             uintptr
	FzName             uintptr
	FpAppData          uintptr
	FxOpen             uintptr
	FxDelete           uintptr
	FxAccess           uintptr
	FxFullPathname     uintptr
	FxDlOpen           uintptr
	FxDlError          uintptr
	FxDlSym            uintptr
	FxDlClose          uintptr
	FxRandomness       uintptr
	FxSleep            uintptr
	FxCurrentTime      uintptr
	FxGetLastError     uintptr
	FxCurrentTimeInt64 uintptr
	FxSetSystemCall    uintptr
	FxGetSystemCall    uintptr
	FxNextSystemCall   uintptr
}

C documentation

/*
** Forward declaration of objects used by this utility
*/

type TMergeEngine

type TMergeEngine = struct {
	FnTree  int32
	FpTask  uintptr
	FaTree  uintptr
	FaReadr uintptr
}

C documentation

/*
** Private objects used by the sorter
*/

type TMergeEngine1

type TMergeEngine1 = struct {
	FnTree  int32
	FpTask  uintptr
	FaTree  uintptr
	FaReadr uintptr
}

** The MergeEngine object is used to combine two or more smaller PMAs into ** one big PMA using a merge operation. Separate PMAs all need to be ** combined into one big PMA in order to be able to step through the sorted ** records in order. ** ** The aReadr[] array contains a PmaReader object for each of the PMAs being ** merged. An aReadr[] object either points to a valid key or else is at EOF. ** ("EOF" means "End Of File". When aReadr[] is at EOF there is no more data.) ** For the purposes of the paragraphs below, we assume that the array is ** actually N elements in size, where N is the smallest power of 2 greater ** to or equal to the number of PMAs being merged. The extra aReadr[] elements ** are treated as if they are empty (always at EOF). ** ** The aTree[] array is also N elements in size. The value of N is stored in ** the MergeEngine.nTree variable. ** ** The final (N/2) elements of aTree[] contain the results of comparing ** pairs of PMA keys together. Element i contains the result of ** comparing aReadr[2*i-N] and aReadr[2*i-N+1]. Whichever key is smaller, the ** aTree element is set to the index of it. ** ** For the purposes of this comparison, EOF is considered greater than any ** other key value. If the keys are equal (only possible with two EOF ** values), it doesn't matter which index is stored. ** ** The (N/4) elements of aTree[] that precede the final (N/2) described ** above contains the index of the smallest of each block of 4 PmaReaders ** And so on. So that aTree[1] contains the index of the PmaReader that ** currently points to the smallest key value. aTree[0] is unused. ** ** Example: ** ** aReadr[0] -> Banana ** aReadr[1] -> Feijoa ** aReadr[2] -> Elderberry ** aReadr[3] -> Currant ** aReadr[4] -> Grapefruit ** aReadr[5] -> Apple ** aReadr[6] -> Durian ** aReadr[7] -> EOF ** ** aTree[] = { X, 5 0, 5 0, 3, 5, 6 } ** ** The current element is "Apple" (the value of the key indicated by ** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will ** be advanced to the next key in its segment. Say the next key is ** "Eggplant": ** ** aReadr[5] -> Eggplant ** ** The contents of aTree[] are updated first by comparing the new PmaReader ** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader ** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree. ** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader ** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Banana<Durian), ** so the value written into element 1 of the array is 0. As follows: ** ** aTree[] = { X, 0 0, 6 0, 3, 5, 6 } ** ** In other words, each time we advance to the next sorter element, log2(N) ** key comparison operations are required, where N is the number of segments ** being merged (rounded up to the next power of 2).

type TModule

type TModule = struct {
	FpModule    uintptr
	FzName      uintptr
	FnRefModule int32
	FpAux       uintptr
	FxDestroy   uintptr
	FpEpoTab    uintptr
}

type TModule1

type TModule1 = struct {
	FpModule    uintptr
	FzName      uintptr
	FnRefModule int32
	FpAux       uintptr
	FxDestroy   uintptr
	FpEpoTab    uintptr
}

** Each SQLite module (virtual table definition) is defined by an ** instance of the following structure, stored in the sqlite3.aModule ** hash table.

type TNameContext

type TNameContext = struct {
	FpParse   uintptr
	FpSrcList uintptr
	FuNC      struct {
		FpAggInfo [0]uintptr
		FpUpsert  [0]uintptr
		FiBaseReg [0]int32
		FpEList   uintptr
	}
	FpNext         uintptr
	FnRef          int32
	FnNcErr        int32
	FncFlags       int32
	FnNestedSelect Tu32
	FpWinSelect    uintptr
}

type TNameContext1

type TNameContext1 = struct {
	FpParse   uintptr
	FpSrcList uintptr
	FuNC      struct {
		FpAggInfo [0]uintptr
		FpUpsert  [0]uintptr
		FiBaseReg [0]int32
		FpEList   uintptr
	}
	FpNext         uintptr
	FnRef          int32
	FnNcErr        int32
	FncFlags       int32
	FnNestedSelect Tu32
	FpWinSelect    uintptr
}

** A NameContext defines a context in which to resolve table and column ** names. The context consists of a list of tables (the pSrcList) field and ** a list of named expression (pEList). The named expression list may ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or ** to the table being operated on by INSERT, UPDATE, or DELETE. The ** pEList corresponds to the result set of a SELECT and is NULL for ** other statements. ** ** NameContexts can be nested. When resolving names, the inner-most ** context is searched first. If no match is found, the next outer ** context is checked. If there is still no match, the next context ** is checked. This process continues until either a match is found ** or all contexts are check. When a match is found, the nRef member of ** the context containing the match is incremented. ** ** Each subquery gets a new NameContext. The pNext field points to the ** NameContext in the parent query. Thus the process of scanning the ** NameContext list corresponds to searching through successively outer ** subqueries looking for a match.

type TNanInfName

type TNanInfName = struct {
	Fc1     int8
	Fc2     int8
	Fn      int8
	FeType  int8
	FnRepl  int8
	FzMatch uintptr
	FzRepl  uintptr
}

C documentation

/*
** Extra floating-point literals to allow in JSON.
*/

type TNthValueCtx

type TNthValueCtx = struct {
	FnStep  Ti64
	FpValue uintptr
}

** Implementation of built-in window function nth_value(). This ** implementation is used in "slow mode" only - when the EXCLUDE clause ** is not set to the default value "NO OTHERS".

type TNtileCtx

type TNtileCtx = struct {
	FnTotal Ti64
	FnParam Ti64
	FiRow   Ti64
}

** Context object for ntile() window function.

type TOnOrUsing

type TOnOrUsing = struct {
	FpOn    uintptr
	FpUsing uintptr
}

type TOnOrUsing1

type TOnOrUsing1 = struct {
	FpOn    uintptr
	FpUsing uintptr
}

** The OnOrUsing object represents either an ON clause or a USING clause. ** It can never be both at the same time, but it can be neither.

type TOp

type TOp = struct {
	Fopcode Tu8
	Fp4type int8
	Fp5     Tu16
	Fp1     int32
	Fp2     int32
	Fp3     int32
	Fp4     Tp4union
}

C documentation

/*
** SQL is translated into a sequence of instructions to be
** executed by a virtual machine.  Each instruction is an instance
** of the following structure.
*/

type TPCache

type TPCache = struct {
	FpDirty     uintptr
	FpDirtyTail uintptr
	FpSynced    uintptr
	FnRefSum    Ti64
	FszCache    int32
	FszSpill    int32
	FszPage     int32
	FszExtra    int32
	FbPurgeable Tu8
	FeCreate    Tu8
	FxStress    uintptr
	FpStress    uintptr
	FpCache     uintptr
}

type TPCache1

type TPCache1 = struct {
	FpGroup          uintptr
	FpnPurgeable     uintptr
	FszPage          int32
	FszExtra         int32
	FszAlloc         int32
	FbPurgeable      int32
	FnMin            uint32
	FnMax            uint32
	Fn90pct          uint32
	FiMaxKey         uint32
	FnPurgeableDummy uint32
	FnRecyclable     uint32
	FnPage           uint32
	FnHash           uint32
	FapHash          uintptr
	FpFree           uintptr
	FpBulk           uintptr
}

type TPCache11

type TPCache11 = struct {
	FpGroup          uintptr
	FpnPurgeable     uintptr
	FszPage          int32
	FszExtra         int32
	FszAlloc         int32
	FbPurgeable      int32
	FnMin            uint32
	FnMax            uint32
	Fn90pct          uint32
	FiMaxKey         uint32
	FnPurgeableDummy uint32
	FnRecyclable     uint32
	FnPage           uint32
	FnHash           uint32
	FapHash          uintptr
	FpFree           uintptr
	FpBulk           uintptr
}

Each page cache is an instance of the following object.  Every

** open database file (including each in-memory database and each ** temporary or transient database) has a single page cache which ** is an instance of this object. ** ** Pointers to structures of this type are cast and returned as ** opaque sqlite3_pcache* handles.

type TPCache2

type TPCache2 = struct {
	FpDirty     uintptr
	FpDirtyTail uintptr
	FpSynced    uintptr
	FnRefSum    Ti64
	FszCache    int32
	FszSpill    int32
	FszPage     int32
	FszExtra    int32
	FbPurgeable Tu8
	FeCreate    Tu8
	FxStress    uintptr
	FpStress    uintptr
	FpCache     uintptr
}

** A complete page cache is an instance of this structure. Every ** entry in the cache holds a single page of the database file. The ** btree layer only operates on the cached copy of the database pages. ** ** A page cache entry is "clean" if it exactly matches what is currently ** on disk. A page is "dirty" if it has been modified and needs to be ** persisted to disk. ** ** pDirty, pDirtyTail, pSynced: ** All dirty pages are linked into the doubly linked list using ** PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order ** such that p was added to the list more recently than p->pDirtyNext. ** PCache.pDirty points to the first (newest) element in the list and ** pDirtyTail to the last (oldest). ** ** The PCache.pSynced variable is used to optimize searching for a dirty ** page to eject from the cache mid-transaction. It is better to eject ** a page that does not require a journal sync than one that does. ** Therefore, pSynced is maintained so that it *almost* always points ** to either the oldest page in the pDirty/pDirtyTail list that has a ** clear PGHDR_NEED_SYNC flag or to a page that is older than this one ** (so that the right page to eject can be found by following pDirtyPrev ** pointers).

type TPCacheGlobal

type TPCacheGlobal = struct {
	Fgrp            TPGroup
	FisInit         int32
	FseparateCache  int32
	FnInitPage      int32
	FszSlot         int32
	FnSlot          int32
	FnReserve       int32
	FpStart         uintptr
	FpEnd           uintptr
	Fmutex          uintptr
	FpFree          uintptr
	FnFreeSlot      int32
	FbUnderPressure int32
}

C documentation

/*
** Global data used by this cache.
*/

type TPGroup

type TPGroup = struct {
	Fmutex      uintptr
	FnMaxPage   uint32
	FnMinPage   uint32
	FmxPinned   uint32
	FnPurgeable uint32
	Flru        TPgHdr1
}

type TPGroup1

type TPGroup1 = struct {
	Fmutex      uintptr
	FnMaxPage   uint32
	FnMinPage   uint32
	FmxPinned   uint32
	FnPurgeable uint32
	Flru        TPgHdr1
}

Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set

** of one or more PCaches that are able to recycle each other's unpinned ** pages when they are under memory pressure. A PGroup is an instance of ** the following object. ** ** This page cache implementation works in one of two modes: ** ** (1) Every PCache is the sole member of its own PGroup. There is ** one PGroup per PCache. ** ** (2) There is a single global PGroup that all PCaches are a member ** of. ** ** Mode 1 uses more memory (since PCache instances are not able to rob ** unused pages from other PCaches) but it also operates without a mutex, ** and is therefore often faster. Mode 2 requires a mutex in order to be ** threadsafe, but recycles pages more efficiently. ** ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single ** PGroup which is the pcache1.grp global variable and its mutex is ** SQLITE_MUTEX_STATIC_LRU.

type TPager

type TPager = struct {
	FpVfs              uintptr
	FexclusiveMode     Tu8
	FjournalMode       Tu8
	FuseJournal        Tu8
	FnoSync            Tu8
	FfullSync          Tu8
	FextraSync         Tu8
	FsyncFlags         Tu8
	FwalSyncFlags      Tu8
	FtempFile          Tu8
	FnoLock            Tu8
	FreadOnly          Tu8
	FmemDb             Tu8
	FmemVfs            Tu8
	FeState            Tu8
	FeLock             Tu8
	FchangeCountDone   Tu8
	FsetSuper          Tu8
	FdoNotSpill        Tu8
	FsubjInMemory      Tu8
	FbUseFetch         Tu8
	FhasHeldSharedLock Tu8
	FdbSize            TPgno
	FdbOrigSize        TPgno
	FdbFileSize        TPgno
	FdbHintSize        TPgno
	FerrCode           int32
	FnRec              int32
	FcksumInit         Tu32
	FnSubRec           Tu32
	FpInJournal        uintptr
	Ffd                uintptr
	Fjfd               uintptr
	Fsjfd              uintptr
	FjournalOff        Ti64
	FjournalHdr        Ti64
	FpBackup           uintptr
	FaSavepoint        uintptr
	FnSavepoint        int32
	FiDataVersion      Tu32
	FdbFileVers        [16]int8
	FnMmapOut          int32
	FszMmap            Tsqlite3_int64
	FpMmapFreelist     uintptr
	FnExtra            Tu16
	FnReserve          Ti16
	FvfsFlags          Tu32
	FsectorSize        Tu32
	FmxPgno            TPgno
	FlckPgno           TPgno
	FpageSize          Ti64
	FjournalSizeLimit  Ti64
	FzFilename         uintptr
	FzJournal          uintptr
	FxBusyHandler      uintptr
	FpBusyHandlerArg   uintptr
	FaStat             [4]Tu32
	FxReiniter         uintptr
	FxGet              uintptr
	FpTmpSpace         uintptr
	FpPCache           uintptr
	FpWal              uintptr
	FzWal              uintptr
}

C documentation

/*
** Each open file is managed by a separate instance of the "Pager" structure.
*/

type TPager1

type TPager1 = struct {
	FpVfs              uintptr
	FexclusiveMode     Tu8
	FjournalMode       Tu8
	FuseJournal        Tu8
	FnoSync            Tu8
	FfullSync          Tu8
	FextraSync         Tu8
	FsyncFlags         Tu8
	FwalSyncFlags      Tu8
	FtempFile          Tu8
	FnoLock            Tu8
	FreadOnly          Tu8
	FmemDb             Tu8
	FmemVfs            Tu8
	FeState            Tu8
	FeLock             Tu8
	FchangeCountDone   Tu8
	FsetSuper          Tu8
	FdoNotSpill        Tu8
	FsubjInMemory      Tu8
	FbUseFetch         Tu8
	FhasHeldSharedLock Tu8
	FdbSize            TPgno
	FdbOrigSize        TPgno
	FdbFileSize        TPgno
	FdbHintSize        TPgno
	FerrCode           int32
	FnRec              int32
	FcksumInit         Tu32
	FnSubRec           Tu32
	FpInJournal        uintptr
	Ffd                uintptr
	Fjfd               uintptr
	Fsjfd              uintptr
	FjournalOff        Ti64
	FjournalHdr        Ti64
	FpBackup           uintptr
	FaSavepoint        uintptr
	FnSavepoint        int32
	FiDataVersion      Tu32
	FdbFileVers        [16]int8
	FnMmapOut          int32
	FszMmap            Tsqlite3_int64
	FpMmapFreelist     uintptr
	FnExtra            Tu16
	FnReserve          Ti16
	FvfsFlags          Tu32
	FsectorSize        Tu32
	FmxPgno            TPgno
	FlckPgno           TPgno
	FpageSize          Ti64
	FjournalSizeLimit  Ti64
	FzFilename         uintptr
	FzJournal          uintptr
	FxBusyHandler      uintptr
	FpBusyHandlerArg   uintptr
	FaStat             [4]Tu32
	FxReiniter         uintptr
	FxGet              uintptr
	FpTmpSpace         uintptr
	FpPCache           uintptr
	FpWal              uintptr
	FzWal              uintptr
}

** An open page cache is an instance of struct Pager. A description of ** some of the more important member variables follows: ** ** eState ** ** The current 'state' of the pager object. See the comment and state ** diagram above for a description of the pager state. ** ** eLock ** ** For a real on-disk database, the current lock held on the database file - ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. ** ** For a temporary or in-memory database (neither of which require any ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such ** databases always have Pager.exclusiveMode==1, this tricks the pager ** logic into thinking that it already has all the locks it will ever ** need (and no reason to release them). ** ** In some (obscure) circumstances, this variable may also be set to ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for ** details. ** ** changeCountDone ** ** This boolean variable is used to make sure that the change-counter ** (the 4-byte header field at byte offset 24 of the database file) is ** not updated more often than necessary. ** ** It is set to true when the change-counter field is updated, which ** can only happen if an exclusive lock is held on the database file. ** It is cleared (set to false) whenever an exclusive lock is ** relinquished on the database file. Each time a transaction is committed, ** The changeCountDone flag is inspected. If it is true, the work of ** updating the change-counter is omitted for the current transaction. ** ** This mechanism means that when running in exclusive mode, a connection ** need only update the change-counter once, for the first transaction ** committed. ** ** setSuper ** ** When PagerCommitPhaseOne() is called to commit a transaction, it may ** (or may not) specify a super-journal name to be written into the ** journal file before it is synced to disk. ** ** Whether or not a journal file contains a super-journal pointer affects ** the way in which the journal file is finalized after the transaction is ** committed or rolled back when running in "journal_mode=PERSIST" mode. ** If a journal file does not contain a super-journal pointer, it is ** finalized by overwriting the first journal header with zeroes. If ** it does contain a super-journal pointer the journal file is finalized ** by truncating it to zero bytes, just as if the connection were ** running in "journal_mode=truncate" mode. ** ** Journal files that contain super-journal pointers cannot be finalized ** simply by overwriting the first journal-header with zeroes, as the ** super-journal pointer could interfere with hot-journal rollback of any ** subsequently interrupted transaction that reuses the journal file. ** ** The flag is cleared as soon as the journal file is finalized (either ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the ** journal file from being successfully finalized, the setSuper flag ** is cleared anyway (and the pager will move to ERROR state). ** ** doNotSpill ** ** This variables control the behavior of cache-spills (calls made by ** the pcache module to the pagerStress() routine to write cached data ** to the file-system in order to free up memory). ** ** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set, ** writing to the database from pagerStress() is disabled altogether. ** The SPILLFLAG_ROLLBACK case is done in a very obscure case that ** comes up during savepoint rollback that requires the pcache module ** to allocate a new page to prevent the journal file from being written ** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF ** case is a user preference. ** ** If the SPILLFLAG_NOSYNC bit is set, writing to the database from ** pagerStress() is permitted, but syncing the journal file is not. ** This flag is set by sqlite3PagerWrite() when the file-system sector-size ** is larger than the database page-size in order to prevent a journal sync ** from happening in between the journalling of two pages on the same sector. ** ** subjInMemory ** ** This is a boolean variable. If true, then any required sub-journal ** is opened as an in-memory journal file. If false, then in-memory ** sub-journals are only used for in-memory pager files. ** ** This variable is updated by the upper layer each time a new ** write-transaction is opened. ** ** dbSize, dbOrigSize, dbFileSize ** ** Variable dbSize is set to the number of pages in the database file. ** It is valid in PAGER_READER and higher states (all states except for ** OPEN and ERROR). ** ** dbSize is set based on the size of the database file, which may be ** larger than the size of the database (the value stored at offset ** 28 of the database header by the btree). If the size of the file ** is not an integer multiple of the page-size, the value stored in ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2). ** Except, any file that is greater than 0 bytes in size is considered ** to have at least one page. (i.e. a 1KB file with 2K page-size leads ** to dbSize==1). ** ** During a write-transaction, if pages with page-numbers greater than ** dbSize are modified in the cache, dbSize is updated accordingly. ** Similarly, if the database is truncated using PagerTruncateImage(), ** dbSize is updated. ** ** Variables dbOrigSize and dbFileSize are valid in states ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize ** variable at the start of the transaction. It is used during rollback, ** and to determine whether or not pages need to be journalled before ** being modified. ** ** Throughout a write-transaction, dbFileSize contains the size of ** the file on disk in pages. It is set to a copy of dbSize when the ** write-transaction is first opened, and updated when VFS calls are made ** to write or truncate the database file on disk. ** ** The only reason the dbFileSize variable is required is to suppress ** unnecessary calls to xTruncate() after committing a transaction. If, ** when a transaction is committed, the dbFileSize variable indicates ** that the database file is larger than the database image (Pager.dbSize), ** pager_truncate() is called. The pager_truncate() call uses xFilesize() ** to measure the database file on disk, and then truncates it if required. ** dbFileSize is not used when rolling back a transaction. In this case ** pager_truncate() is called unconditionally (which means there may be ** a call to xFilesize() that is not strictly required). In either case, ** pager_truncate() may cause the file to become smaller or larger. ** ** dbHintSize ** ** The dbHintSize variable is used to limit the number of calls made to ** the VFS xFileControl(FCNTL_SIZE_HINT) method. ** ** dbHintSize is set to a copy of the dbSize variable when a ** write-transaction is opened (at the same time as dbFileSize and ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called, ** dbHintSize is increased to the number of pages that correspond to the ** size-hint passed to the method call. See pager_write_pagelist() for ** details. ** ** errCode ** ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX ** sub-codes. ** ** syncFlags, walSyncFlags ** ** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03). ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode ** and contains the flags used to sync the checkpoint operations in the ** lower two bits, and sync flags used for transaction commits in the WAL ** file in bits 0x04 and 0x08. In other words, to get the correct sync flags ** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct ** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced ** meaning that the 0x04 and 0x08 bits are both zero.

type TPagerSavepoint

type TPagerSavepoint = struct {
	FiOffset            Ti64
	FiHdrOffset         Ti64
	FpInSavepoint       uintptr
	FnOrig              TPgno
	FiSubRec            TPgno
	FbTruncateOnRelease int32
	FaWalData           [4]Tu32
}

C documentation

/*
** An instance of the following structure is allocated for each active
** savepoint and statement transaction in the system. All such structures
** are stored in the Pager.aSavepoint[] array, which is allocated and
** resized using sqlite3Realloc().
**
** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
** set to 0. If a journal-header is written into the main journal while
** the savepoint is active, then iHdrOffset is set to the byte offset
** immediately following the last journal record written into the main
** journal before the journal-header. This is required during savepoint
** rollback (see pagerPlaybackSavepoint()).
*/

type TPagerSavepoint1

type TPagerSavepoint1 = struct {
	FiOffset            Ti64
	FiHdrOffset         Ti64
	FpInSavepoint       uintptr
	FnOrig              TPgno
	FiSubRec            TPgno
	FbTruncateOnRelease int32
	FaWalData           [4]Tu32
}

type TParse

type TParse = struct {
	Fdb               uintptr
	FzErrMsg          uintptr
	FpVdbe            uintptr
	Frc               int32
	FcolNamesSet      Tu8
	FcheckSchema      Tu8
	Fnested           Tu8
	FnTempReg         Tu8
	FisMultiWrite     Tu8
	FmayAbort         Tu8
	FhasCompound      Tu8
	FokConstFactor    Tu8
	FdisableLookaside Tu8
	FprepFlags        Tu8
	FwithinRJSubrtn   Tu8
	FbHasWith         Tu8
	FnRangeReg        int32
	FiRangeReg        int32
	FnErr             int32
	FnTab             int32
	FnMem             int32
	FszOpAlloc        int32
	FiSelfTab         int32
	FnLabel           int32
	FnLabelAlloc      int32
	FaLabel           uintptr
	FpConstExpr       uintptr
	FpIdxEpr          uintptr
	FpIdxPartExpr     uintptr
	FconstraintName   TToken
	FwriteMask        TyDbMask
	FcookieMask       TyDbMask
	FregRowid         int32
	FregRoot          int32
	FnMaxArg          int32
	FnSelect          int32
	FnProgressSteps   Tu32
	FnTableLock       int32
	FaTableLock       uintptr
	FpAinc            uintptr
	FpToplevel        uintptr
	FpTriggerTab      uintptr
	FpTriggerPrg      uintptr
	FpCleanup         uintptr
	Fu1               struct {
		FpReturning  [0]uintptr
		FaddrCrTab   int32
		F__ccgo_pad2 [4]byte
	}
	Foldmask         Tu32
	Fnewmask         Tu32
	FnQueryLoop      TLogEst
	FeTriggerOp      Tu8
	FbReturning      Tu8
	FeOrconf         Tu8
	FdisableTriggers Tu8
	FaTempReg        [8]int32
	FpOuterParse     uintptr
	FsNameToken      TToken
	FsLastToken      TToken
	FnVar            TynVar
	FiPkSortOrder    Tu8
	Fexplain         Tu8
	FeParseMode      Tu8
	FnVtabLock       int32
	FnHeight         int32
	FaddrExplain     int32
	FpVList          uintptr
	FpReprepare      uintptr
	FzTail           uintptr
	FpNewTable       uintptr
	FpNewIndex       uintptr
	FpNewTrigger     uintptr
	FzAuthContext    uintptr
	FsArg            TToken
	FapVtabLock      uintptr
	FpWith           uintptr
	FpRename         uintptr
}

type TParse1

type TParse1 = struct {
	Fdb               uintptr
	FzErrMsg          uintptr
	FpVdbe            uintptr
	Frc               int32
	FcolNamesSet      Tu8
	FcheckSchema      Tu8
	Fnested           Tu8
	FnTempReg         Tu8
	FisMultiWrite     Tu8
	FmayAbort         Tu8
	FhasCompound      Tu8
	FokConstFactor    Tu8
	FdisableLookaside Tu8
	FprepFlags        Tu8
	FwithinRJSubrtn   Tu8
	FbHasWith         Tu8
	FnRangeReg        int32
	FiRangeReg        int32
	FnErr             int32
	FnTab             int32
	FnMem             int32
	FszOpAlloc        int32
	FiSelfTab         int32
	FnLabel           int32
	FnLabelAlloc      int32
	FaLabel           uintptr
	FpConstExpr       uintptr
	FpIdxEpr          uintptr
	FpIdxPartExpr     uintptr
	FconstraintName   TToken
	FwriteMask        TyDbMask
	FcookieMask       TyDbMask
	FregRowid         int32
	FregRoot          int32
	FnMaxArg          int32
	FnSelect          int32
	FnProgressSteps   Tu32
	FnTableLock       int32
	FaTableLock       uintptr
	FpAinc            uintptr
	FpToplevel        uintptr
	FpTriggerTab      uintptr
	FpTriggerPrg      uintptr
	FpCleanup         uintptr
	Fu1               struct {
		FpReturning  [0]uintptr
		FaddrCrTab   int32
		F__ccgo_pad2 [4]byte
	}
	Foldmask         Tu32
	Fnewmask         Tu32
	FnQueryLoop      TLogEst
	FeTriggerOp      Tu8
	FbReturning      Tu8
	FeOrconf         Tu8
	FdisableTriggers Tu8
	FaTempReg        [8]int32
	FpOuterParse     uintptr
	FsNameToken      TToken
	FsLastToken      TToken
	FnVar            TynVar
	FiPkSortOrder    Tu8
	Fexplain         Tu8
	FeParseMode      Tu8
	FnVtabLock       int32
	FnHeight         int32
	FaddrExplain     int32
	FpVList          uintptr
	FpReprepare      uintptr
	FzTail           uintptr
	FpNewTable       uintptr
	FpNewIndex       uintptr
	FpNewTrigger     uintptr
	FzAuthContext    uintptr
	FsArg            TToken
	FapVtabLock      uintptr
	FpWith           uintptr
	FpRename         uintptr
}

** An SQL parser context. A copy of this structure is passed through ** the parser and down into all the parser action routine in order to ** carry around information that is global to the entire parse. ** ** The structure is divided into two parts. When the parser and code ** generate call themselves recursively, the first part of the structure ** is constant but the second part is reset at the beginning and end of ** each recursion. ** ** The nTableLock and aTableLock variables are only used if the shared-cache ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are ** used to store the set of table-locks required by the statement being ** compiled. Function sqlite3TableLock() is used to add entries to the ** list.

type TParseCleanup

type TParseCleanup = struct {
	FpNext    uintptr
	FpPtr     uintptr
	FxCleanup uintptr
}

type TParseCleanup1

type TParseCleanup1 = struct {
	FpNext    uintptr
	FpPtr     uintptr
	FxCleanup uintptr
}

** An instance of the ParseCleanup object specifies an operation that ** should be performed after parsing to deallocation resources obtained ** during the parse and which are no longer needed.

type TPgFreeslot

type TPgFreeslot = struct {
	FpNext uintptr
}

type TPgFreeslot1

type TPgFreeslot1 = struct {
	FpNext uintptr
}

** Free slots in the allocator used to divide up the global page cache ** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism.

type TPgHdr

type TPgHdr = struct {
	FpPage      uintptr
	FpData      uintptr
	FpExtra     uintptr
	FpCache     uintptr
	FpDirty     uintptr
	FpPager     uintptr
	Fpgno       TPgno
	Fflags      Tu16
	FnRef       Ti64
	FpDirtyNext uintptr
	FpDirtyPrev uintptr
}

type TPgHdr1

type TPgHdr1 = struct {
	Fpage        Tsqlite3_pcache_page
	FiKey        uint32
	FisBulkLocal Tu16
	FisAnchor    Tu16
	FpNext       uintptr
	FpCache      uintptr
	FpLruNext    uintptr
	FpLruPrev    uintptr
}

type TPgHdr11

type TPgHdr11 = struct {
	Fpage        Tsqlite3_pcache_page
	FiKey        uint32
	FisBulkLocal Tu16
	FisAnchor    Tu16
	FpNext       uintptr
	FpCache      uintptr
	FpLruNext    uintptr
	FpLruPrev    uintptr
}

** Each cache entry is represented by an instance of the following ** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated ** directly before this structure and is used to cache the page content. ** ** When reading a corrupt database file, it is possible that SQLite might ** read a few bytes (no more than 16 bytes) past the end of the page buffer. ** It will only read past the end of the page buffer, never write. This ** object is positioned immediately after the page buffer to serve as an ** overrun area, so that overreads are harmless. ** ** Variables isBulkLocal and isAnchor were once type "u8". That works, ** but causes a 2-byte gap in the structure for most architectures (since ** pointers must be either 4 or 8-byte aligned). As this structure is located ** in memory directly after the associated page data, if the database is ** corrupt, code at the b-tree layer may overread the page buffer and ** read part of this structure before the corruption is detected. This ** can cause a valgrind error if the uninitialized gap is accessed. Using u16 ** ensures there is no such gap, and therefore no bytes of uninitialized ** memory in the structure. ** ** The pLruNext and pLruPrev pointers form a double-linked circular list ** of all pages that are unpinned. The PGroup.lru element (which should be ** the only element on the list with PgHdr1.isAnchor set to 1) forms the ** beginning and the end of the list.

type TPgHdr2

type TPgHdr2 = TDbPage

C documentation

/*
** Handle type for pages.
*/

type TPgno

type TPgno = uint32

C documentation

/*
** The type used to represent a page number.  The first page in a file
** is called page 1.  0 is used to represent "not a page".
*/

type TPmaReader

type TPmaReader = struct {
	FiReadOff Ti64
	FiEof     Ti64
	FnAlloc   int32
	FnKey     int32
	FpFd      uintptr
	FaAlloc   uintptr
	FaKey     uintptr
	FaBuffer  uintptr
	FnBuffer  int32
	FaMap     uintptr
	FpIncr    uintptr
}

Merge PMAs together

type TPmaReader1

type TPmaReader1 = struct {
	FiReadOff Ti64
	FiEof     Ti64
	FnAlloc   int32
	FnKey     int32
	FpFd      uintptr
	FaAlloc   uintptr
	FaKey     uintptr
	FaBuffer  uintptr
	FnBuffer  int32
	FaMap     uintptr
	FpIncr    uintptr
}

** An instance of the following object is used to read records out of a ** PMA, in sorted order. The next key to be read is cached in nKey/aKey. ** aKey might point into aMap or into aBuffer. If neither of those locations ** contain a contiguous representation of the key, then aAlloc is allocated ** and the key is copied into aAlloc and aKey is made to point to aAlloc. ** ** pFd==0 at EOF.

type TPmaWriter

type TPmaWriter = struct {
	FeFWErr    int32
	FaBuffer   uintptr
	FnBuffer   int32
	FiBufStart int32
	FiBufEnd   int32
	FiWriteOff Ti64
	FpFd       uintptr
}

Incrementally read one PMA

type TPmaWriter1

type TPmaWriter1 = struct {
	FeFWErr    int32
	FaBuffer   uintptr
	FnBuffer   int32
	FiBufStart int32
	FiBufEnd   int32
	FiWriteOff Ti64
	FpFd       uintptr
}

** An instance of this object is used for writing a PMA. ** ** The PMA is written one record at a time. Each record is of an arbitrary ** size. But I/O is more efficient if it occurs in page-sized blocks where ** each block is aligned on a page boundary. This object caches writes to ** the PMA so that aligned, page-size blocks are written.

type TPorterContext

type TPorterContext = struct {
	FpCtx   uintptr
	FxToken uintptr
	FaBuf   uintptr
}

type TPorterContext1

type TPorterContext1 = struct {
	FpCtx   uintptr
	FxToken uintptr
	FaBuf   uintptr
}

type TPorterRule

type TPorterRule = struct {
	FzSuffix uintptr
	FnSuffix int32
	FxCond   uintptr
	FzOutput uintptr
	FnOutput int32
}

type TPorterRule1

type TPorterRule1 = struct {
	FzSuffix uintptr
	FnSuffix int32
	FxCond   uintptr
	FzOutput uintptr
	FnOutput int32
}

type TPorterTokenizer

type TPorterTokenizer = struct {
	Ftokenizer  Tfts5_tokenizer
	FpTokenizer uintptr
	FaBuf       [128]int8
}

type TPorterTokenizer1

type TPorterTokenizer1 = struct {
	Ftokenizer  Tfts5_tokenizer
	FpTokenizer uintptr
	FaBuf       [128]int8
}

type TPoslistCallbackCtx

type TPoslistCallbackCtx = struct {
	FpBuf    uintptr
	FpColset uintptr
	FeState  int32
}

type TPoslistCallbackCtx1

type TPoslistCallbackCtx1 = struct {
	FpBuf    uintptr
	FpColset uintptr
	FeState  int32
}

type TPoslistOffsetsCtx

type TPoslistOffsetsCtx = struct {
	FpBuf    uintptr
	FpColset uintptr
	FiRead   int32
	FiWrite  int32
}

type TPoslistOffsetsCtx1

type TPoslistOffsetsCtx1 = struct {
	FpBuf    uintptr
	FpColset uintptr
	FiRead   int32
	FiWrite  int32
}

type TPragmaName

type TPragmaName = struct {
	FzName      uintptr
	FePragTyp   Tu8
	FmPragFlg   Tu8
	FiPragCName Tu8
	FnPragCName Tu8
	FiArg       Tu64
}

C documentation

/* Definitions of all built-in pragmas */

type TPragmaVtab

type TPragmaVtab = struct {
	Fbase    Tsqlite3_vtab
	Fdb      uintptr
	FpName   uintptr
	FnHidden Tu8
	FiHidden Tu8
}

C documentation

/*****************************************************************************
** Implementation of an eponymous virtual table that runs a pragma.
**
*/

type TPragmaVtab1

type TPragmaVtab1 = struct {
	Fbase    Tsqlite3_vtab
	Fdb      uintptr
	FpName   uintptr
	FnHidden Tu8
	FiHidden Tu8
}

type TPragmaVtabCursor

type TPragmaVtabCursor = struct {
	Fbase    Tsqlite3_vtab_cursor
	FpPragma uintptr
	FiRowid  Tsqlite_int64
	FazArg   [2]uintptr
}

type TPragmaVtabCursor1

type TPragmaVtabCursor1 = struct {
	Fbase    Tsqlite3_vtab_cursor
	FpPragma uintptr
	FiRowid  Tsqlite_int64
	FazArg   [2]uintptr
}

type TPreUpdate

type TPreUpdate = struct {
	Fv            uintptr
	FpCsr         uintptr
	Fop           int32
	FaRecord      uintptr
	Fkeyinfo      TKeyInfo
	FpUnpacked    uintptr
	FpNewUnpacked uintptr
	FiNewReg      int32
	FiBlobWrite   int32
	FiKey1        Ti64
	FiKey2        Ti64
	FaNew         uintptr
	FpTab         uintptr
	FpPk          uintptr
}

type TPreUpdate1

type TPreUpdate1 = struct {
	Fv            uintptr
	FpCsr         uintptr
	Fop           int32
	FaRecord      uintptr
	Fkeyinfo      TKeyInfo
	FpUnpacked    uintptr
	FpNewUnpacked uintptr
	FiNewReg      int32
	FiBlobWrite   int32
	FiKey1        Ti64
	FiKey2        Ti64
	FaNew         uintptr
	FpTab         uintptr
	FpPk          uintptr
}

** Structure used to store the context required by the ** sqlite3_preupdate_*() API functions.

type TPrefixMerger

type TPrefixMerger = struct {
	Fiter  TFts5DoclistIter
	FiPos  Ti64
	FiOff  int32
	FaPos  uintptr
	FpNext uintptr
}

type TPrefixMerger1

type TPrefixMerger1 = struct {
	Fiter  TFts5DoclistIter
	FiPos  Ti64
	FiOff  int32
	FaPos  uintptr
	FpNext uintptr
}

type TPrintfArguments

type TPrintfArguments = struct {
	FnArg  int32
	FnUsed int32
	FapArg uintptr
}

type TPrintfArguments1

type TPrintfArguments1 = struct {
	FnArg  int32
	FnUsed int32
	FapArg uintptr
}

** An instance of the following structure holds information about SQL ** functions arguments that are the parameters to the printf() function.

type TRCStr

type TRCStr = struct {
	FnRCRef Tu64
}

type TRCStr1

type TRCStr1 = struct {
	FnRCRef Tu64
}

** The following object is the header for an "RCStr" or "reference-counted ** string". An RCStr is passed around and used like any other char* ** that has been dynamically allocated. The important interface ** differences: ** ** 1. RCStr strings are reference counted. They are deallocated ** when the reference count reaches zero. ** ** 2. Use sqlite3RCStrUnref() to free an RCStr string rather than ** sqlite3_free() ** ** 3. Make a (read-only) copy of a read-only RCStr string using ** sqlite3RCStrRef(). ** ** "String" is in the name, but an RCStr object can also be used to hold ** binary data.

type TRbuFrame

type TRbuFrame = struct {
	FiDbPage   Tu32
	FiWalFrame Tu32
}

type TRbuFrame1

type TRbuFrame1 = struct {
	FiDbPage   Tu32
	FiWalFrame Tu32
}

** A single step of an incremental checkpoint - frame iWalFrame of the wal ** file should be copied to page iDbPage of the database file.

type TRbuObjIter

type TRbuObjIter = struct {
	FpTblIter   uintptr
	FpIdxIter   uintptr
	FnTblCol    int32
	FazTblCol   uintptr
	FazTblType  uintptr
	FaiSrcOrder uintptr
	FabTblPk    uintptr
	FabNotNull  uintptr
	FabIndexed  uintptr
	FeType      int32
	FbCleanup   int32
	FzTbl       uintptr
	FzDataTbl   uintptr
	FzIdx       uintptr
	FiTnum      int32
	FiPkTnum    int32
	FbUnique    int32
	FnIndex     int32
	FnCol       int32
	FpSelect    uintptr
	FpInsert    uintptr
	FpDelete    uintptr
	FpTmpInsert uintptr
	FnIdxCol    int32
	FaIdxCol    uintptr
	FzIdxSql    uintptr
	FpRbuUpdate uintptr
}

type TRbuObjIter1

type TRbuObjIter1 = struct {
	FpTblIter   uintptr
	FpIdxIter   uintptr
	FnTblCol    int32
	FazTblCol   uintptr
	FazTblType  uintptr
	FaiSrcOrder uintptr
	FabTblPk    uintptr
	FabNotNull  uintptr
	FabIndexed  uintptr
	FeType      int32
	FbCleanup   int32
	FzTbl       uintptr
	FzDataTbl   uintptr
	FzIdx       uintptr
	FiTnum      int32
	FiPkTnum    int32
	FbUnique    int32
	FnIndex     int32
	FnCol       int32
	FpSelect    uintptr
	FpInsert    uintptr
	FpDelete    uintptr
	FpTmpInsert uintptr
	FnIdxCol    int32
	FaIdxCol    uintptr
	FzIdxSql    uintptr
	FpRbuUpdate uintptr
}

** An iterator of this type is used to iterate through all objects in ** the target database that require updating. For each such table, the ** iterator visits, in order: ** ** * the table itself, ** * each index of the table (zero or more points to visit), and ** * a special "cleanup table" state. ** ** abIndexed: ** If the table has no indexes on it, abIndexed is set to NULL. Otherwise, ** it points to an array of flags nTblCol elements in size. The flag is ** set for each column that is either a part of the PK or a part of an ** index. Or clear otherwise. ** ** If there are one or more partial indexes on the table, all fields of ** this array set set to 1. This is because in that case, the module has ** no way to tell which fields will be required to add and remove entries ** from the partial indexes. **

type TRbuSpan

type TRbuSpan = struct {
	FzSpan uintptr
	FnSpan int32
}

type TRbuSpan1

type TRbuSpan1 = struct {
	FzSpan uintptr
	FnSpan int32
}

type TRbuState

type TRbuState = struct {
	FeStage        int32
	FzTbl          uintptr
	FzDataTbl      uintptr
	FzIdx          uintptr
	FiWalCksum     Ti64
	FnRow          int32
	FnProgress     Ti64
	FiCookie       Tu32
	FiOalSz        Ti64
	FnPhaseOneStep Ti64
}

type TRbuState1

type TRbuState1 = struct {
	FeStage        int32
	FzTbl          uintptr
	FzDataTbl      uintptr
	FzIdx          uintptr
	FiWalCksum     Ti64
	FnRow          int32
	FnProgress     Ti64
	FiCookie       Tu32
	FiOalSz        Ti64
	FnPhaseOneStep Ti64
}

** A structure to store values read from the rbu_state table in memory.

type TRbuUpdateStmt

type TRbuUpdateStmt = struct {
	FzMask   uintptr
	FpUpdate uintptr
	FpNext   uintptr
}

type TRbuUpdateStmt1

type TRbuUpdateStmt1 = struct {
	FzMask   uintptr
	FpUpdate uintptr
	FpNext   uintptr
}

type TRecordCompare

type TRecordCompare = uintptr

type TRefSrcList

type TRefSrcList = struct {
	Fdb        uintptr
	FpRef      uintptr
	FnExclude  Ti64
	FaiExclude uintptr
}

Structure used to pass information throughout the Walker in order to

** implement sqlite3ReferencesSrcList().

type TRenameCtx

type TRenameCtx = struct {
	FpList uintptr
	FnList int32
	FiCol  int32
	FpTab  uintptr
	FzOld  uintptr
}

C documentation

/*
** The context of an ALTER TABLE RENAME COLUMN operation that gets passed
** down into the Walker.
*/

type TRenameCtx1

type TRenameCtx1 = struct {
	FpList uintptr
	FnList int32
	FiCol  int32
	FpTab  uintptr
	FzOld  uintptr
}

type TRenameToken

type TRenameToken = struct {
	Fp     uintptr
	Ft     TToken
	FpNext uintptr
}

type TRenameToken1

type TRenameToken1 = struct {
	Fp     uintptr
	Ft     TToken
	FpNext uintptr
}

** Each RenameToken object maps an element of the parse tree into ** the token that generated that element. The parse tree element ** might be one of: ** ** * A pointer to an Expr that represents an ID ** * The name of a table column in Column.zName ** ** A list of RenameToken objects can be constructed during parsing. ** Each new object is created by sqlite3RenameTokenMap(). ** As the parse tree is transformed, the sqlite3RenameTokenRemap() ** routine is used to keep the mapping current. ** ** After the parse finishes, renameTokenFind() routine can be used ** to look up the actual token value that created some element in ** the parse tree.

type TReturning

type TReturning = struct {
	FpParse    uintptr
	FpReturnEL uintptr
	FretTrig   TTrigger
	FretTStep  TTriggerStep
	FiRetCur   int32
	FnRetCol   int32
	FiRetReg   int32
	FzName     [40]int8
}

type TReturning1

type TReturning1 = struct {
	FpParse    uintptr
	FpReturnEL uintptr
	FretTrig   TTrigger
	FretTStep  TTriggerStep
	FiRetCur   int32
	FnRetCol   int32
	FiRetReg   int32
	FzName     [40]int8
}

** Information about a RETURNING clause

type TReusableSpace

type TReusableSpace = struct {
	FpSpace  uintptr
	FnFree   Tsqlite3_int64
	FnNeeded Tsqlite3_int64
}

An instance of this object describes bulk memory available for use

** by subcomponents of a prepared statement. Space is allocated out ** of a ReusableSpace object by the allocSpace() routine below.

type TRowLoadInfo

type TRowLoadInfo = struct {
	FregResult int32
	FecelFlags Tu8
}

C documentation

/*
** An instance of this object holds information (beyond pParse and pSelect)
** needed to load the next result row that is to be added to the sorter.
*/

type TRowLoadInfo1

type TRowLoadInfo1 = struct {
	FregResult int32
	FecelFlags Tu8
}

type TRowSet

type TRowSet = struct {
	FpChunk  uintptr
	Fdb      uintptr
	FpEntry  uintptr
	FpLast   uintptr
	FpFresh  uintptr
	FpForest uintptr
	FnFresh  Tu16
	FrsFlags Tu16
	FiBatch  int32
}

type TRowSet1

type TRowSet1 = struct {
	FpChunk  uintptr
	Fdb      uintptr
	FpEntry  uintptr
	FpLast   uintptr
	FpFresh  uintptr
	FpForest uintptr
	FnFresh  Tu16
	FrsFlags Tu16
	FiBatch  int32
}

** A RowSet in an instance of the following structure. ** ** A typedef of this structure if found in sqliteInt.h.

type TRowSetChunk

type TRowSetChunk = struct {
	FpNextChunk uintptr
	FaEntry     [42]TRowSetEntry
}

** RowSetEntry objects are allocated in large chunks (instances of the ** following structure) to reduce memory allocation overhead. The ** chunks are kept on a linked list so that they can be deallocated ** when the RowSet is destroyed.

type TRowSetEntry

type TRowSetEntry = struct {
	Fv      Ti64
	FpRight uintptr
	FpLeft  uintptr
}

** Each entry in a RowSet is an instance of the following object. ** ** This same object is reused to store a linked list of trees of RowSetEntry ** objects. In that alternative use, pRight points to the next entry ** in the list, pLeft points to the tree, and v is unused. The ** RowSet.pForest value points to the head of this forest list.

type TRtree

type TRtree = struct {
	Fbase          Tsqlite3_vtab
	Fdb            uintptr
	FiNodeSize     int32
	FnDim          Tu8
	FnDim2         Tu8
	FeCoordType    Tu8
	FnBytesPerCell Tu8
	FinWrTrans     Tu8
	FnAux          Tu8
	FnAuxNotNull   Tu8
	FiDepth        int32
	FzDb           uintptr
	FzName         uintptr
	FzNodeName     uintptr
	FnBusy         Tu32
	FnRowEst       Ti64
	FnCursor       Tu32
	FnNodeRef      Tu32
	FzReadAuxSql   uintptr
	FpDeleted      uintptr
	FpNodeBlob     uintptr
	FpWriteNode    uintptr
	FpDeleteNode   uintptr
	FpReadRowid    uintptr
	FpWriteRowid   uintptr
	FpDeleteRowid  uintptr
	FpReadParent   uintptr
	FpWriteParent  uintptr
	FpDeleteParent uintptr
	FpWriteAux     uintptr
	FaHash         [97]uintptr
}

type TRtree1

type TRtree1 = struct {
	Fbase          Tsqlite3_vtab
	Fdb            uintptr
	FiNodeSize     int32
	FnDim          Tu8
	FnDim2         Tu8
	FeCoordType    Tu8
	FnBytesPerCell Tu8
	FinWrTrans     Tu8
	FnAux          Tu8
	FnAuxNotNull   Tu8
	FiDepth        int32
	FzDb           uintptr
	FzName         uintptr
	FzNodeName     uintptr
	FnBusy         Tu32
	FnRowEst       Ti64
	FnCursor       Tu32
	FnNodeRef      Tu32
	FzReadAuxSql   uintptr
	FpDeleted      uintptr
	FpNodeBlob     uintptr
	FpWriteNode    uintptr
	FpDeleteNode   uintptr
	FpReadRowid    uintptr
	FpWriteRowid   uintptr
	FpDeleteRowid  uintptr
	FpReadParent   uintptr
	FpWriteParent  uintptr
	FpDeleteParent uintptr
	FpWriteAux     uintptr
	FaHash         [97]uintptr
}

** An rtree virtual-table object.

type TRtreeCell

type TRtreeCell = struct {
	FiRowid Ti64
	FaCoord [10]TRtreeCoord
}

type TRtreeCell1

type TRtreeCell1 = struct {
	FiRowid Ti64
	FaCoord [10]TRtreeCoord
}

** A single cell from a node, deserialized

type TRtreeCheck

type TRtreeCheck = struct {
	Fdb            uintptr
	FzDb           uintptr
	FzTab          uintptr
	FbInt          int32
	FnDim          int32
	FpGetNode      uintptr
	FaCheckMapping [2]uintptr
	FnLeaf         int32
	FnNonLeaf      int32
	Frc            int32
	FzReport       uintptr
	FnErr          int32
}

C documentation

/*
** Context object passed between the various routines that make up the
** implementation of integrity-check function rtreecheck().
*/

type TRtreeCheck1

type TRtreeCheck1 = struct {
	Fdb            uintptr
	FzDb           uintptr
	FzTab          uintptr
	FbInt          int32
	FnDim          int32
	FpGetNode      uintptr
	FaCheckMapping [2]uintptr
	FnLeaf         int32
	FnNonLeaf      int32
	Frc            int32
	FzReport       uintptr
	FnErr          int32
}

type TRtreeConstraint

type TRtreeConstraint = struct {
	FiCoord int32
	Fop     int32
	Fu      struct {
		FxGeom      [0]uintptr
		FxQueryFunc [0]uintptr
		FrValue     TRtreeDValue
	}
	FpInfo uintptr
}

type TRtreeConstraint1

type TRtreeConstraint1 = struct {
	FiCoord int32
	Fop     int32
	Fu      struct {
		FxGeom      [0]uintptr
		FxQueryFunc [0]uintptr
		FrValue     TRtreeDValue
	}
	FpInfo uintptr
}

** A search constraint.

type TRtreeCoord

type TRtreeCoord = struct {
	Fi [0]int32
	Fu [0]Tu32
	Ff TRtreeValue
}

type TRtreeCoord1

type TRtreeCoord1 = struct {
	Fi [0]int32
	Fu [0]Tu32
	Ff TRtreeValue
}

** A coordinate can be either a floating point number or a integer. All ** coordinates within a single R-Tree are always of the same time.

type TRtreeCursor

type TRtreeCursor = struct {
	Fbase        Tsqlite3_vtab_cursor
	FatEOF       Tu8
	FbPoint      Tu8
	FbAuxValid   Tu8
	FiStrategy   int32
	FnConstraint int32
	FaConstraint uintptr
	FnPointAlloc int32
	FnPoint      int32
	FmxLevel     int32
	FaPoint      uintptr
	FpReadAux    uintptr
	FsPoint      TRtreeSearchPoint
	FaNode       [5]uintptr
	FanQueue     [41]Tu32
}

type TRtreeCursor1

type TRtreeCursor1 = struct {
	Fbase        Tsqlite3_vtab_cursor
	FatEOF       Tu8
	FbPoint      Tu8
	FbAuxValid   Tu8
	FiStrategy   int32
	FnConstraint int32
	FaConstraint uintptr
	FnPointAlloc int32
	FnPoint      int32
	FmxLevel     int32
	FaPoint      uintptr
	FpReadAux    uintptr
	FsPoint      TRtreeSearchPoint
	FaNode       [5]uintptr
	FanQueue     [41]Tu32
}

** An rtree cursor object.

type TRtreeDValue

type TRtreeDValue = float64

C documentation

/*
** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will
** only deal with integer coordinates.  No floating point operations
** will be done.
*/

type TRtreeGeomCallback

type TRtreeGeomCallback = struct {
	FxGeom       uintptr
	FxQueryFunc  uintptr
	FxDestructor uintptr
	FpContext    uintptr
}

type TRtreeGeomCallback1

type TRtreeGeomCallback1 = struct {
	FxGeom       uintptr
	FxQueryFunc  uintptr
	FxDestructor uintptr
	FpContext    uintptr
}

** This object becomes the sqlite3_user_data() for the SQL functions ** that are created by sqlite3_rtree_geometry_callback() and ** sqlite3_rtree_query_callback() and which appear on the right of MATCH ** operators in order to constrain a search. ** ** xGeom and xQueryFunc are the callback functions. Exactly one of ** xGeom and xQueryFunc fields is non-NULL, depending on whether the ** SQL function was created using sqlite3_rtree_geometry_callback() or ** sqlite3_rtree_query_callback(). ** ** This object is deleted automatically by the destructor mechanism in ** sqlite3_create_function_v2().

type TRtreeMatchArg

type TRtreeMatchArg = struct {
	FiSize      Tu32
	Fcb         TRtreeGeomCallback
	FnParam     int32
	FapSqlParam uintptr
	FaParam     [1]TRtreeDValue
}

type TRtreeMatchArg1

type TRtreeMatchArg1 = struct {
	FiSize      Tu32
	Fcb         TRtreeGeomCallback
	FnParam     int32
	FapSqlParam uintptr
	FaParam     [1]TRtreeDValue
}

** An instance of this structure (in the form of a BLOB) is returned by ** the SQL functions that sqlite3_rtree_geometry_callback() and ** sqlite3_rtree_query_callback() create, and is read as the right-hand ** operand to the MATCH operator of an R-Tree.

type TRtreeNode

type TRtreeNode = struct {
	FpParent uintptr
	FiNode   Ti64
	FnRef    int32
	FisDirty int32
	FzData   uintptr
	FpNext   uintptr
}

type TRtreeNode1

type TRtreeNode1 = struct {
	FpParent uintptr
	FiNode   Ti64
	FnRef    int32
	FisDirty int32
	FzData   uintptr
	FpNext   uintptr
}

** An rtree structure node.

type TRtreeSearchPoint

type TRtreeSearchPoint = struct {
	FrScore  TRtreeDValue
	Fid      Tsqlite3_int64
	FiLevel  Tu8
	FeWithin Tu8
	FiCell   Tu8
}

type TRtreeSearchPoint1

type TRtreeSearchPoint1 = struct {
	FrScore  TRtreeDValue
	Fid      Tsqlite3_int64
	FiLevel  Tu8
	FeWithin Tu8
	FiCell   Tu8
}

** When doing a search of an r-tree, instances of the following structure ** record intermediate results from the tree walk. ** ** The id is always a node-id. For iLevel>=1 the id is the node-id of ** the node that the RtreeSearchPoint represents. When iLevel==0, however, ** the id is of the parent node and the cell that RtreeSearchPoint ** represents is the iCell-th entry in the parent node.

type TRtreeValue

type TRtreeValue = float32

type TSQLiteThread

type TSQLiteThread = struct {
	Ftid   Tpthread_t
	Fdone  int32
	FpOut  uintptr
	FxTask uintptr
	FpIn   uintptr
}

type TSQLiteThread1

type TSQLiteThread1 = struct {
	Ftid   Tpthread_t
	Fdone  int32
	FpOut  uintptr
	FxTask uintptr
	FpIn   uintptr
}

A running thread

type TSavepoint

type TSavepoint = struct {
	FzName            uintptr
	FnDeferredCons    Ti64
	FnDeferredImmCons Ti64
	FpNext            uintptr
}

type TSavepoint1

type TSavepoint1 = struct {
	FzName            uintptr
	FnDeferredCons    Ti64
	FnDeferredImmCons Ti64
	FpNext            uintptr
}

** All current savepoints are stored in a linked list starting at ** sqlite3.pSavepoint. The first element in the list is the most recently ** opened savepoint. Savepoints are added to the list by the vdbe ** OP_Savepoint instruction.

type TScanStatus

type TScanStatus = struct {
	FaddrExplain int32
	FaAddrRange  [6]int32
	FaddrLoop    int32
	FaddrVisit   int32
	FiSelectID   int32
	FnEst        TLogEst
	FzName       uintptr
}

C documentation

/* The ScanStatus object holds a single value for the
** sqlite3_stmt_scanstatus() interface.
**
** aAddrRange[]:
**   This array is used by ScanStatus elements associated with EQP
**   notes that make an SQLITE_SCANSTAT_NCYCLE value available. It is
**   an array of up to 3 ranges of VM addresses for which the Vdbe.anCycle[]
**   values should be summed to calculate the NCYCLE value. Each pair of
**   integer addresses is a start and end address (both inclusive) for a range
**   instructions. A start value of 0 indicates an empty range.
*/

type TScanStatus1

type TScanStatus1 = struct {
	FaddrExplain int32
	FaAddrRange  [6]int32
	FaddrLoop    int32
	FaddrVisit   int32
	FiSelectID   int32
	FnEst        TLogEst
	FzName       uintptr
}

type TSchema

type TSchema = struct {
	Fschema_cookie int32
	FiGeneration   int32
	FtblHash       THash
	FidxHash       THash
	FtrigHash      THash
	FfkeyHash      THash
	FpSeqTab       uintptr
	Ffile_format   Tu8
	Fenc           Tu8
	FschemaFlags   Tu16
	Fcache_size    int32
}

type TSchema1

type TSchema1 = struct {
	Fschema_cookie int32
	FiGeneration   int32
	FtblHash       THash
	FidxHash       THash
	FtrigHash      THash
	FfkeyHash      THash
	FpSeqTab       uintptr
	Ffile_format   Tu8
	Fenc           Tu8
	FschemaFlags   Tu16
	Fcache_size    int32
}

** An instance of the following structure stores a database schema. ** ** Most Schema objects are associated with a Btree. The exception is ** the Schema for the TEMP database (sqlite3.aDb[1]) which is free-standing. ** In shared cache mode, a single Schema object can be shared by multiple ** Btrees that refer to the same underlying BtShared object. ** ** Schema objects are automatically deallocated when the last Btree that ** references them is destroyed. The TEMP Schema is manually freed by ** sqlite3_close(). * ** A thread must be holding a mutex on the corresponding Btree in order ** to access Schema content. This implies that the thread must also be ** holding a mutex on the sqlite3 connection pointer that owns the Btree. ** For a TEMP Schema, only the connection mutex is required.

type TSelect

type TSelect = struct {
	Fop           Tu8
	FnSelectRow   TLogEst
	FselFlags     Tu32
	FiLimit       int32
	FiOffset      int32
	FselId        Tu32
	FaddrOpenEphm [2]int32
	FpEList       uintptr
	FpSrc         uintptr
	FpWhere       uintptr
	FpGroupBy     uintptr
	FpHaving      uintptr
	FpOrderBy     uintptr
	FpPrior       uintptr
	FpNext        uintptr
	FpLimit       uintptr
	FpWith        uintptr
	FpWin         uintptr
	FpWinDefn     uintptr
}

type TSelect1

type TSelect1 = struct {
	Fop           Tu8
	FnSelectRow   TLogEst
	FselFlags     Tu32
	FiLimit       int32
	FiOffset      int32
	FselId        Tu32
	FaddrOpenEphm [2]int32
	FpEList       uintptr
	FpSrc         uintptr
	FpWhere       uintptr
	FpGroupBy     uintptr
	FpHaving      uintptr
	FpOrderBy     uintptr
	FpPrior       uintptr
	FpNext        uintptr
	FpLimit       uintptr
	FpWith        uintptr
	FpWin         uintptr
	FpWinDefn     uintptr
}

** An instance of the following structure contains all information ** needed to generate code for a single SELECT statement. ** ** See the header comment on the computeLimitRegisters() routine for a ** detailed description of the meaning of the iLimit and iOffset fields. ** ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes. ** These addresses must be stored so that we can go back and fill in ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor ** the number of columns in P2 can be computed at the same time ** as the OP_OpenEphm instruction is coded because not ** enough information about the compound query is known at that point. ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating ** sequences for the ORDER BY clause.

type TSelectDest

type TSelectDest = struct {
	FeDest    Tu8
	FiSDParm  int32
	FiSDParm2 int32
	FiSdst    int32
	FnSdst    int32
	FzAffSdst uintptr
	FpOrderBy uintptr
}

type TSelectDest1

type TSelectDest1 = struct {
	FeDest    Tu8
	FiSDParm  int32
	FiSDParm2 int32
	FiSdst    int32
	FnSdst    int32
	FzAffSdst uintptr
	FpOrderBy uintptr
}

** An instance of this object describes where to put of the results of ** a SELECT statement.

type TSessionApplyCtx

type TSessionApplyCtx = struct {
	Fdb                 uintptr
	FpDelete            uintptr
	FpInsert            uintptr
	FpSelect            uintptr
	FnCol               int32
	FazCol              uintptr
	FabPK               uintptr
	FaUpdateMask        uintptr
	FpUp                uintptr
	FbStat1             int32
	FbDeferConstraints  int32
	FbInvertConstraints int32
	Fconstraints        TSessionBuffer
	Frebase             TSessionBuffer
	FbRebaseStarted     Tu8
	FbRebase            Tu8
	FbIgnoreNoop        Tu8
	FbRowid             int32
}

type TSessionApplyCtx1

type TSessionApplyCtx1 = struct {
	Fdb                 uintptr
	FpDelete            uintptr
	FpInsert            uintptr
	FpSelect            uintptr
	FnCol               int32
	FazCol              uintptr
	FabPK               uintptr
	FaUpdateMask        uintptr
	FpUp                uintptr
	FbStat1             int32
	FbDeferConstraints  int32
	FbInvertConstraints int32
	Fconstraints        TSessionBuffer
	Frebase             TSessionBuffer
	FbRebaseStarted     Tu8
	FbRebase            Tu8
	FbIgnoreNoop        Tu8
	FbRowid             int32
}

type TSessionBuffer

type TSessionBuffer = struct {
	FaBuf   uintptr
	FnBuf   int32
	FnAlloc int32
}

type TSessionBuffer1

type TSessionBuffer1 = struct {
	FaBuf   uintptr
	FnBuf   int32
	FnAlloc int32
}

** Instances of this structure are used to build strings or binary records.

type TSessionChange

type TSessionChange = struct {
	Fop           Tu8
	FbIndirect    Tu8
	FnRecordField Tu16
	FnMaxSize     int32
	FnRecord      int32
	FaRecord      uintptr
	FpNext        uintptr
}

type TSessionChange1

type TSessionChange1 = struct {
	Fop           Tu8
	FbIndirect    Tu8
	FnRecordField Tu16
	FnMaxSize     int32
	FnRecord      int32
	FaRecord      uintptr
	FpNext        uintptr
}

** For each row modified during a session, there exists a single instance of ** this structure stored in a SessionTable.aChange[] hash table.

type TSessionDiffCtx

type TSessionDiffCtx = struct {
	FpStmt   uintptr
	FbRowid  int32
	FnOldOff int32
}

type TSessionDiffCtx1

type TSessionDiffCtx1 = struct {
	FpStmt   uintptr
	FbRowid  int32
	FnOldOff int32
}

type TSessionHook

type TSessionHook = struct {
	FpCtx   uintptr
	FxOld   uintptr
	FxNew   uintptr
	FxCount uintptr
	FxDepth uintptr
}

type TSessionHook1

type TSessionHook1 = struct {
	FpCtx   uintptr
	FxOld   uintptr
	FxNew   uintptr
	FxCount uintptr
	FxDepth uintptr
}

type TSessionInput

type TSessionInput = struct {
	FbNoDiscard int32
	FiCurrent   int32
	FiNext      int32
	FaData      uintptr
	FnData      int32
	Fbuf        TSessionBuffer
	FxInput     uintptr
	FpIn        uintptr
	FbEof       int32
}

type TSessionInput1

type TSessionInput1 = struct {
	FbNoDiscard int32
	FiCurrent   int32
	FiNext      int32
	FaData      uintptr
	FnData      int32
	Fbuf        TSessionBuffer
	FxInput     uintptr
	FpIn        uintptr
	FbEof       int32
}

** An object of this type is used internally as an abstraction for ** input data. Input data may be supplied either as a single large buffer ** (e.g. sqlite3changeset_start()) or using a stream function (e.g. ** sqlite3changeset_start_strm()).

type TSessionStat1Ctx

type TSessionStat1Ctx = struct {
	Fhook     TSessionHook
	FpSession uintptr
}

C documentation

/*
** Versions of the four methods in object SessionHook for use with the
** sqlite_stat1 table. The purpose of this is to substitute a zero-length
** blob each time a NULL value is read from the "idx" column of the
** sqlite_stat1 table.
*/

type TSessionStat1Ctx1

type TSessionStat1Ctx1 = struct {
	Fhook     TSessionHook
	FpSession uintptr
}

type TSessionTable

type TSessionTable = struct {
	FpNext     uintptr
	FzName     uintptr
	FnCol      int32
	FbStat1    int32
	FbRowid    int32
	FazCol     uintptr
	FazDflt    uintptr
	FabPK      uintptr
	FnEntry    int32
	FnChange   int32
	FapChange  uintptr
	FpDfltStmt uintptr
}

type TSessionTable1

type TSessionTable1 = struct {
	FpNext     uintptr
	FzName     uintptr
	FnCol      int32
	FbStat1    int32
	FbRowid    int32
	FazCol     uintptr
	FazDflt    uintptr
	FabPK      uintptr
	FnEntry    int32
	FnChange   int32
	FapChange  uintptr
	FpDfltStmt uintptr
}

** Each session object maintains a set of the following structures, one ** for each table the session object is monitoring. The structures are ** stored in a linked list starting at sqlite3_session.pTable. ** ** The keys of the SessionTable.aChange[] hash table are all rows that have ** been modified in any way since the session object was attached to the ** table. ** ** The data associated with each hash-table entry is a structure containing ** a subset of the initial values that the modified row contained at the ** start of the session. Or no initial values if the row was inserted. ** ** pDfltStmt: ** This is only used by the sqlite3changegroup_xxx() APIs, not by ** regular sqlite3_session objects. It is a SELECT statement that ** selects the default value for each table column. For example, ** if the table is ** ** CREATE TABLE xx(a DEFAULT 1, b, c DEFAULT 'abc') ** ** then this variable is the compiled version of: ** ** SELECT 1, NULL, 'abc'

type TSessionUpdate

type TSessionUpdate = struct {
	FpStmt uintptr
	FaMask uintptr
	FpNext uintptr
}

type TSessionUpdate1

type TSessionUpdate1 = struct {
	FpStmt uintptr
	FaMask uintptr
	FpNext uintptr
}

type TSortCtx

type TSortCtx = struct {
	FpOrderBy         uintptr
	FnOBSat           int32
	FiECursor         int32
	FregReturn        int32
	FlabelBkOut       int32
	FaddrSortIndex    int32
	FlabelDone        int32
	FlabelOBLopt      int32
	FsortFlags        Tu8
	FpDeferredRowLoad uintptr
}

C documentation

/*
** An instance of the following object is used to record information about
** the ORDER BY (or GROUP BY) clause of query is being coded.
**
** The aDefer[] array is used by the sorter-references optimization. For
** example, assuming there is no index that can be used for the ORDER BY,
** for the query:
**
**     SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10;
**
** it may be more efficient to add just the "a" values to the sorter, and
** retrieve the associated "bigblob" values directly from table t1 as the
** 10 smallest "a" values are extracted from the sorter.
**
** When the sorter-reference optimization is used, there is one entry in the
** aDefer[] array for each database table that may be read as values are
** extracted from the sorter.
*/

type TSortCtx1

type TSortCtx1 = struct {
	FpOrderBy         uintptr
	FnOBSat           int32
	FiECursor         int32
	FregReturn        int32
	FlabelBkOut       int32
	FaddrSortIndex    int32
	FlabelDone        int32
	FlabelOBLopt      int32
	FsortFlags        Tu8
	FpDeferredRowLoad uintptr
}

type TSortSubtask

type TSortSubtask = struct {
	FpThread   uintptr
	FbDone     int32
	FnPMA      int32
	FpSorter   uintptr
	FpUnpacked uintptr
	Flist      TSorterList
	FxCompare  TSorterCompare
	Ffile      TSorterFile
	Ffile2     TSorterFile
}

A record being sorted

type TSortSubtask1

type TSortSubtask1 = struct {
	FpThread   uintptr
	FbDone     int32
	FnPMA      int32
	FpSorter   uintptr
	FpUnpacked uintptr
	Flist      TSorterList
	FxCompare  TSorterCompare
	Ffile      TSorterFile
	Ffile2     TSorterFile
}

type TSorterCompare

type TSorterCompare = uintptr

C documentation

/*
** This object represents a single thread of control in a sort operation.
** Exactly VdbeSorter.nTask instances of this object are allocated
** as part of each VdbeSorter object. Instances are never allocated any
** other way. VdbeSorter.nTask is set to the number of worker threads allowed
** (see SQLITE_CONFIG_WORKER_THREADS) plus one (the main thread).  Thus for
** single-threaded operation, there is exactly one instance of this object
** and for multi-threaded operation there are two or more instances.
**
** Essentially, this structure contains all those fields of the VdbeSorter
** structure for which each thread requires a separate instance. For example,
** each thread requeries its own UnpackedRecord object to unpack records in
** as part of comparison operations.
**
** Before a background thread is launched, variable bDone is set to 0. Then,
** right before it exits, the thread itself sets bDone to 1. This is used for
** two purposes:
**
**   1. When flushing the contents of memory to a level-0 PMA on disk, to
**      attempt to select a SortSubtask for which there is not already an
**      active background thread (since doing so causes the main thread
**      to block until it finishes).
**
**   2. If SQLITE_DEBUG_SORTER_THREADS is defined, to determine if a call
**      to sqlite3ThreadJoin() is likely to block. Cases that are likely to
**      block provoke debugging output.
**
** In both cases, the effects of the main thread seeing (bDone==0) even
** after the thread has finished are not dire. So we don't worry about
** memory barriers and such here.
*/

type TSorterFile

type TSorterFile = struct {
	FpFd  uintptr
	FiEof Ti64
}

A sub-task in the sort process

type TSorterFile1

type TSorterFile1 = struct {
	FpFd  uintptr
	FiEof Ti64
}

** A container for a temp file handle and the current amount of data ** stored in the file.

type TSorterList

type TSorterList = struct {
	FpList   uintptr
	FaMemory uintptr
	FszPMA   Ti64
}

Temporary file object wrapper

type TSorterList1

type TSorterList1 = struct {
	FpList   uintptr
	FaMemory uintptr
	FszPMA   Ti64
}

** An in-memory list of objects to be sorted. ** ** If aMemory==0 then each object is allocated separately and the objects ** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects ** are stored in the aMemory[] bulk memory, one right after the other, and ** are connected using SorterRecord.u.iNext.

type TSorterRecord

type TSorterRecord = struct {
	FnVal int32
	Fu    struct {
		FiNext [0]int32
		FpNext uintptr
	}
}

Incrementally write one PMA

type TSorterRecord1

type TSorterRecord1 = struct {
	FnVal int32
	Fu    struct {
		FiNext [0]int32
		FpNext uintptr
	}
}

** This object is the header on a single record while that record is being ** held in memory and prior to being written out as part of a PMA. ** ** How the linked list is connected depends on how memory is being managed ** by this module. If using a separate allocation for each in-memory record ** (VdbeSorter.list.aMemory==0), then the list is always connected using the ** SorterRecord.u.pNext pointers. ** ** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0), ** then while records are being accumulated the list is linked using the ** SorterRecord.u.iNext offset. This is because the aMemory[] array may ** be sqlite3Realloc()ed while records are being accumulated. Once the VM ** has finished passing records to the sorter, or when the in-memory buffer ** is full, the list is sorted. As part of the sorting process, it is ** converted to use the SorterRecord.u.pNext pointers. See function ** vdbeSorterSort() for details.

type TSqlite3Config

type TSqlite3Config = struct {
	FbMemstat            int32
	FbCoreMutex          Tu8
	FbFullMutex          Tu8
	FbOpenUri            Tu8
	FbUseCis             Tu8
	FbSmallMalloc        Tu8
	FbExtraSchemaChecks  Tu8
	FbUseLongDouble      Tu8
	FmxStrlen            int32
	FneverCorrupt        int32
	FszLookaside         int32
	FnLookaside          int32
	FnStmtSpill          int32
	Fm                   Tsqlite3_mem_methods
	Fmutex               Tsqlite3_mutex_methods
	Fpcache2             Tsqlite3_pcache_methods2
	FpHeap               uintptr
	FnHeap               int32
	FmnReq               int32
	FmxReq               int32
	FszMmap              Tsqlite3_int64
	FmxMmap              Tsqlite3_int64
	FpPage               uintptr
	FszPage              int32
	FnPage               int32
	FmxParserStack       int32
	FsharedCacheEnabled  int32
	FszPma               Tu32
	FisInit              int32
	FinProgress          int32
	FisMutexInit         int32
	FisMallocInit        int32
	FisPCacheInit        int32
	FnRefInitMutex       int32
	FpInitMutex          uintptr
	FxLog                uintptr
	FpLogArg             uintptr
	FmxMemdbSize         Tsqlite3_int64
	FxTestCallback       uintptr
	FbLocaltimeFault     int32
	FxAltLocaltime       uintptr
	FiOnceResetThreshold int32
	FszSorterRef         Tu32
	FiPrngSeed           uint32
}

** Structure containing global configuration data for the SQLite library. ** ** This structure also contains some state information.

type TSrcItem

type TSrcItem = struct {
	FpSchema     uintptr
	FzDatabase   uintptr
	FzName       uintptr
	FzAlias      uintptr
	FpTab        uintptr
	FpSelect     uintptr
	FaddrFillSub int32
	FregReturn   int32
	FregResult   int32
	Ffg          struct {
		F__ccgo_align  [0]uint32
		Fjointype      Tu8
		F__ccgo_align1 [2]byte
		F__ccgo4       uint16
	}
	FiCursor int32
	Fu3      struct {
		FpUsing [0]uintptr
		FpOn    uintptr
	}
	FcolUsed TBitmask
	Fu1      struct {
		FpFuncArg   [0]uintptr
		FnRow       [0]Tu32
		FzIndexedBy uintptr
	}
	Fu2 struct {
		FpCteUse  [0]uintptr
		FpIBIndex uintptr
	}
}

type TSrcItem1

type TSrcItem1 = struct {
	FpSchema     uintptr
	FzDatabase   uintptr
	FzName       uintptr
	FzAlias      uintptr
	FpTab        uintptr
	FpSelect     uintptr
	FaddrFillSub int32
	FregReturn   int32
	FregResult   int32
	Ffg          struct {
		F__ccgo_align  [0]uint32
		Fjointype      Tu8
		F__ccgo_align1 [2]byte
		F__ccgo4       uint16
	}
	FiCursor int32
	Fu3      struct {
		FpUsing [0]uintptr
		FpOn    uintptr
	}
	FcolUsed TBitmask
	Fu1      struct {
		FpFuncArg   [0]uintptr
		FnRow       [0]Tu32
		FzIndexedBy uintptr
	}
	Fu2 struct {
		FpCteUse  [0]uintptr
		FpIBIndex uintptr
	}
}

** The SrcItem object represents a single term in the FROM clause of a query. ** The SrcList object is mostly an array of SrcItems. ** ** The jointype starts out showing the join type between the current table ** and the next table on the list. The parser builds the list this way. ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each ** jointype expresses the join between the table and the previous table. ** ** In the colUsed field, the high-order bit (bit 63) is set if the table ** contains more than 63 columns and the 64-th or later column is used. ** ** Union member validity: ** ** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc ** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy ** u1.nRow !fg.isTabFunc && !fg.isIndexedBy ** ** u2.pIBIndex fg.isIndexedBy && !fg.isCte ** u2.pCteUse fg.isCte && !fg.isIndexedBy

type TSrcList

type TSrcList = struct {
	FnSrc   int32
	FnAlloc Tu32
	Fa      [1]TSrcItem
}

type TSrcList1

type TSrcList1 = struct {
	FnSrc   int32
	FnAlloc Tu32
	Fa      [1]TSrcItem
}

** This object represents one or more tables that are the source of ** content for an SQL statement. For example, a single SrcList object ** is used to hold the FROM clause of a SELECT statement. SrcList also ** represents the target tables for DELETE, INSERT, and UPDATE statements. **

type TStatAccum

type TStatAccum = struct {
	Fdb         uintptr
	FnEst       TtRowcnt
	FnRow       TtRowcnt
	FnLimit     int32
	FnCol       int32
	FnKeyCol    int32
	FnSkipAhead Tu8
	Fcurrent    TStatSample
	FnPSample   TtRowcnt
	FmxSample   int32
	FiPrn       Tu32
	FaBest      uintptr
	FiMin       int32
	FnSample    int32
	FnMaxEqZero int32
	FiGet       int32
	Fa          uintptr
}

C documentation

/*
** Three SQL functions - stat_init(), stat_push(), and stat_get() -
** share an instance of the following structure to hold their state
** information.
*/

type TStatAccum1

type TStatAccum1 = struct {
	Fdb         uintptr
	FnEst       TtRowcnt
	FnRow       TtRowcnt
	FnLimit     int32
	FnCol       int32
	FnKeyCol    int32
	FnSkipAhead Tu8
	Fcurrent    TStatSample
	FnPSample   TtRowcnt
	FmxSample   int32
	FiPrn       Tu32
	FaBest      uintptr
	FiMin       int32
	FnSample    int32
	FnMaxEqZero int32
	FiGet       int32
	Fa          uintptr
}

type TStatCell

type TStatCell = struct {
	FnLocal    int32
	FiChildPg  Tu32
	FnOvfl     int32
	FaOvfl     uintptr
	FnLastOvfl int32
	FiOvfl     int32
}

type TStatCell1

type TStatCell1 = struct {
	FnLocal    int32
	FiChildPg  Tu32
	FnOvfl     int32
	FaOvfl     uintptr
	FnLastOvfl int32
	FiOvfl     int32
}

Size information for a single cell within a btree page

type TStatCursor

type TStatCursor = struct {
	Fbase       Tsqlite3_vtab_cursor
	FpStmt      uintptr
	FisEof      Tu8
	FisAgg      Tu8
	FiDb        int32
	FaPage      [32]TStatPage
	FiPage      int32
	FiPageno    Tu32
	FzName      uintptr
	FzPath      uintptr
	FzPagetype  uintptr
	FnPage      int32
	FnCell      int32
	FnMxPayload int32
	FnUnused    Ti64
	FnPayload   Ti64
	FiOffset    Ti64
	FszPage     Ti64
}

type TStatCursor1

type TStatCursor1 = struct {
	Fbase       Tsqlite3_vtab_cursor
	FpStmt      uintptr
	FisEof      Tu8
	FisAgg      Tu8
	FiDb        int32
	FaPage      [32]TStatPage
	FiPage      int32
	FiPageno    Tu32
	FzName      uintptr
	FzPath      uintptr
	FzPagetype  uintptr
	FnPage      int32
	FnCell      int32
	FnMxPayload int32
	FnUnused    Ti64
	FnPayload   Ti64
	FiOffset    Ti64
	FszPage     Ti64
}

The cursor for scanning the dbstat virtual table

type TStatPage

type TStatPage = struct {
	FiPgno         Tu32
	FaPg           uintptr
	FiCell         int32
	FzPath         uintptr
	Fflags         Tu8
	FnCell         int32
	FnUnused       int32
	FaCell         uintptr
	FiRightChildPg Tu32
	FnMxPayload    int32
}

type TStatPage1

type TStatPage1 = struct {
	FiPgno         Tu32
	FaPg           uintptr
	FiCell         int32
	FzPath         uintptr
	Fflags         Tu8
	FnCell         int32
	FnUnused       int32
	FaCell         uintptr
	FiRightChildPg Tu32
	FnMxPayload    int32
}

Size information for a single btree page

type TStatSample

type TStatSample = struct {
	FanDLt uintptr
	FanEq  uintptr
	FanLt  uintptr
	Fu     struct {
		FaRowid [0]uintptr
		FiRowid Ti64
	}
	FnRowid    Tu32
	FisPSample Tu8
	FiCol      int32
	FiHash     Tu32
}

type TStatSample1

type TStatSample1 = struct {
	FanDLt uintptr
	FanEq  uintptr
	FanLt  uintptr
	Fu     struct {
		FaRowid [0]uintptr
		FiRowid Ti64
	}
	FnRowid    Tu32
	FisPSample Tu8
	FiCol      int32
	FiHash     Tu32
}

type TStatTable

type TStatTable = struct {
	Fbase Tsqlite3_vtab
	Fdb   uintptr
	FiDb  int32
}

C documentation

/* Forward reference to data structured used in this module */

type TStatTable1

type TStatTable1 = struct {
	Fbase Tsqlite3_vtab
	Fdb   uintptr
	FiDb  int32
}

An instance of the DBSTAT virtual table

type TStrAccum

type TStrAccum = struct {
	Fdb          uintptr
	FzText       uintptr
	FnAlloc      Tu32
	FmxAlloc     Tu32
	FnChar       Tu32
	FaccError    Tu8
	FprintfFlags Tu8
}

type TSubProgram

type TSubProgram = struct {
	FaOp   uintptr
	FnOp   int32
	FnMem  int32
	FnCsr  int32
	FaOnce uintptr
	Ftoken uintptr
	FpNext uintptr
}

type TSubProgram1

type TSubProgram1 = struct {
	FaOp   uintptr
	FnOp   int32
	FnMem  int32
	FnCsr  int32
	FaOnce uintptr
	Ftoken uintptr
	FpNext uintptr
}

** A sub-routine used to implement a trigger program.

type TSubstContext

type TSubstContext = struct {
	FpParse      uintptr
	FiTable      int32
	FiNewTable   int32
	FisOuterJoin int32
	FpEList      uintptr
	FpCList      uintptr
}

C documentation

/* An instance of the SubstContext object describes an substitution edit
** to be performed on a parse tree.
**
** All references to columns in table iTable are to be replaced by corresponding
** expressions in pEList.
**
** ## About "isOuterJoin":
**
** The isOuterJoin column indicates that the replacement will occur into a
** position in the parent that NULL-able due to an OUTER JOIN.  Either the
** target slot in the parent is the right operand of a LEFT JOIN, or one of
** the left operands of a RIGHT JOIN.  In either case, we need to potentially
** bypass the substituted expression with OP_IfNullRow.
**
** Suppose the original expression is an integer constant. Even though the table
** has the nullRow flag set, because the expression is an integer constant,
** it will not be NULLed out.  So instead, we insert an OP_IfNullRow opcode
** that checks to see if the nullRow flag is set on the table.  If the nullRow
** flag is set, then the value in the register is set to NULL and the original
** expression is bypassed.  If the nullRow flag is not set, then the original
** expression runs to populate the register.
**
** Example where this is needed:
**
**      CREATE TABLE t1(a INTEGER PRIMARY KEY, b INT);
**      CREATE TABLE t2(x INT UNIQUE);
**
**      SELECT a,b,m,x FROM t1 LEFT JOIN (SELECT 59 AS m,x FROM t2) ON b=x;
**
** When the subquery on the right side of the LEFT JOIN is flattened, we
** have to add OP_IfNullRow in front of the OP_Integer that implements the
** "m" value of the subquery so that a NULL will be loaded instead of 59
** when processing a non-matched row of the left.
*/

type TSumCtx

type TSumCtx = struct {
	FrSum   float64
	FrErr   float64
	FiSum   Ti64
	Fcnt    Ti64
	Fapprox Tu8
	Fovrfl  Tu8
}

C documentation

/*
** An instance of the following structure holds the context of a
** sum() or avg() aggregate computation.
*/

type TSumCtx1

type TSumCtx1 = struct {
	FrSum   float64
	FrErr   float64
	FiSum   Ti64
	Fcnt    Ti64
	Fapprox Tu8
	Fovrfl  Tu8
}

type TTabResult

type TTabResult = struct {
	FazResult uintptr
	FzErrMsg  uintptr
	FnAlloc   Tu32
	FnRow     Tu32
	FnColumn  Tu32
	FnData    Tu32
	Frc       int32
}

C documentation

/*
** This structure is used to pass data from sqlite3_get_table() through
** to the callback function is uses to build the result.
*/

type TTable

type TTable = struct {
	FzName      uintptr
	FaCol       uintptr
	FpIndex     uintptr
	FzColAff    uintptr
	FpCheck     uintptr
	Ftnum       TPgno
	FnTabRef    Tu32
	FtabFlags   Tu32
	FiPKey      Ti16
	FnCol       Ti16
	FnNVCol     Ti16
	FnRowLogEst TLogEst
	FszTabRow   TLogEst
	FkeyConf    Tu8
	FeTabType   Tu8
	Fu          struct {
		Fview [0]struct {
			FpSelect uintptr
		}
		Fvtab [0]struct {
			FnArg  int32
			FazArg uintptr
			Fp     uintptr
		}
		Ftab struct {
			FaddColOffset int32
			FpFKey        uintptr
			FpDfltList    uintptr
		}
	}
	FpTrigger uintptr
	FpSchema  uintptr
}

Internal alias for sqlite3_str

type TTable1

type TTable1 = struct {
	FzName      uintptr
	FaCol       uintptr
	FpIndex     uintptr
	FzColAff    uintptr
	FpCheck     uintptr
	Ftnum       TPgno
	FnTabRef    Tu32
	FtabFlags   Tu32
	FiPKey      Ti16
	FnCol       Ti16
	FnNVCol     Ti16
	FnRowLogEst TLogEst
	FszTabRow   TLogEst
	FkeyConf    Tu8
	FeTabType   Tu8
	Fu          struct {
		Fview [0]struct {
			FpSelect uintptr
		}
		Fvtab [0]struct {
			FnArg  int32
			FazArg uintptr
			Fp     uintptr
		}
		Ftab struct {
			FaddColOffset int32
			FpFKey        uintptr
			FpDfltList    uintptr
		}
	}
	FpTrigger uintptr
	FpSchema  uintptr
}

** The schema for each SQL table, virtual table, and view is represented ** in memory by an instance of the following structure.

type TTableLock

type TTableLock = struct {
	FiDb         int32
	FiTab        TPgno
	FisWriteLock Tu8
	FzLockName   uintptr
}

type TTableLock1

type TTableLock1 = struct {
	FiDb         int32
	FiTab        TPgno
	FisWriteLock Tu8
	FzLockName   uintptr
}

** The TableLock structure is only used by the sqlite3TableLock() and ** codeTableLocks() functions.

type TToken

type TToken = struct {
	Fz uintptr
	Fn uint32
}

type TToken1

type TToken1 = struct {
	Fz uintptr
	Fn uint32
}

** Each token coming out of the lexer is an instance of ** this structure. Tokens are also used as part of an expression. ** ** The memory that "z" points to is owned by other objects. Take care ** that the owner of the "z" string does not deallocate the string before ** the Token goes out of scope! Very often, the "z" points to some place ** in the middle of the Parse.zSql text. But it might also point to a ** static string.

type TTokenCtx

type TTokenCtx = struct {
	FpPhrase uintptr
	FpConfig uintptr
	Frc      int32
}

type TTokenCtx1

type TTokenCtx1 = struct {
	FpPhrase uintptr
	FpConfig uintptr
	Frc      int32
}

type TTrigEvent

type TTrigEvent = struct {
	Fa int32
	Fb uintptr
}

** An instance of the following structure describes the event of a ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, ** TK_DELETE, or TK_INSTEAD. If the event is of the form ** ** UPDATE ON (a,b,c) ** ** Then the "b" IdList records the list "a,b,c".

type TTrigger

type TTrigger = struct {
	FzName      uintptr
	Ftable      uintptr
	Fop         Tu8
	Ftr_tm      Tu8
	FbReturning Tu8
	FpWhen      uintptr
	FpColumns   uintptr
	FpSchema    uintptr
	FpTabSchema uintptr
	Fstep_list  uintptr
	FpNext      uintptr
}

type TTrigger1

type TTrigger1 = struct {
	FzName      uintptr
	Ftable      uintptr
	Fop         Tu8
	Ftr_tm      Tu8
	FbReturning Tu8
	FpWhen      uintptr
	FpColumns   uintptr
	FpSchema    uintptr
	FpTabSchema uintptr
	Fstep_list  uintptr
	FpNext      uintptr
}

** Each trigger present in the database schema is stored as an instance of ** struct Trigger. ** ** Pointers to instances of struct Trigger are stored in two ways. ** 1. In the "trigHash" hash table (part of the sqlite3* that represents the ** database). This allows Trigger structures to be retrieved by name. ** 2. All triggers associated with a single table form a linked list, using the ** pNext member of struct Trigger. A pointer to the first element of the ** linked list is stored as the "pTrigger" member of the associated ** struct Table. ** ** The "step_list" member points to the first element of a linked list ** containing the SQL statements specified as the trigger program.

type TTriggerPrg

type TTriggerPrg = struct {
	FpTrigger uintptr
	FpNext    uintptr
	FpProgram uintptr
	Forconf   int32
	FaColmask [2]Tu32
}

type TTriggerPrg1

type TTriggerPrg1 = struct {
	FpTrigger uintptr
	FpNext    uintptr
	FpProgram uintptr
	Forconf   int32
	FaColmask [2]Tu32
}

** At least one instance of the following structure is created for each ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE ** statement. All such objects are stored in the linked list headed at ** Parse.pTriggerPrg and deleted once statement compilation has been ** completed. ** ** A Vdbe sub-program that implements the body and WHEN clause of trigger ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. ** The Parse.pTriggerPrg list never contains two entries with the same ** values for both pTrigger and orconf. ** ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns ** accessed (or set to 0 for triggers fired as a result of INSERT ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to ** a mask of new.* columns used by the program.

type TTriggerStep

type TTriggerStep = struct {
	Fop        Tu8
	Forconf    Tu8
	FpTrig     uintptr
	FpSelect   uintptr
	FzTarget   uintptr
	FpFrom     uintptr
	FpWhere    uintptr
	FpExprList uintptr
	FpIdList   uintptr
	FpUpsert   uintptr
	FzSpan     uintptr
	FpNext     uintptr
	FpLast     uintptr
}

type TTriggerStep1

type TTriggerStep1 = struct {
	Fop        Tu8
	Forconf    Tu8
	FpTrig     uintptr
	FpSelect   uintptr
	FzTarget   uintptr
	FpFrom     uintptr
	FpWhere    uintptr
	FpExprList uintptr
	FpIdList   uintptr
	FpUpsert   uintptr
	FzSpan     uintptr
	FpNext     uintptr
	FpLast     uintptr
}

** An instance of struct TriggerStep is used to store a single SQL statement ** that is a part of a trigger-program. ** ** Instances of struct TriggerStep are stored in a singly linked list (linked ** using the "pNext" member) referenced by the "step_list" member of the ** associated struct Trigger instance. The first element of the linked list is ** the first step of the trigger-program. ** ** The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or ** "SELECT" statement. The meanings of the other members is determined by the ** value of "op" as follows: ** ** (op == TK_INSERT) ** orconf -> stores the ON CONFLICT algorithm ** pSelect -> The content to be inserted - either a SELECT statement or ** a VALUES clause. ** zTarget -> Dequoted name of the table to insert into. ** pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ... ** statement, then this stores the column-names to be ** inserted into. ** pUpsert -> The ON CONFLICT clauses for an Upsert ** ** (op == TK_DELETE) ** zTarget -> Dequoted name of the table to delete from. ** pWhere -> The WHERE clause of the DELETE statement if one is specified. ** Otherwise NULL. ** ** (op == TK_UPDATE) ** zTarget -> Dequoted name of the table to update. ** pWhere -> The WHERE clause of the UPDATE statement if one is specified. ** Otherwise NULL. ** pExprList -> A list of the columns to update and the expressions to update ** them to. See sqlite3Update() documentation of "pChanges" ** argument. ** ** (op == TK_SELECT) ** pSelect -> The SELECT statement ** ** (op == TK_RETURNING) ** pExprList -> The list of expressions that follow the RETURNING keyword. **

type TTrigramTokenizer

type TTrigramTokenizer = struct {
	FbFold      int32
	FiFoldParam int32
}

C documentation

/**************************************************************************
** Start of trigram implementation.
*/

type TTrigramTokenizer1

type TTrigramTokenizer1 = struct {
	FbFold      int32
	FiFoldParam int32
}

type TUnicode61Tokenizer

type TUnicode61Tokenizer = struct {
	FaTokenChar       [128]uint8
	FaFold            uintptr
	FnFold            int32
	FeRemoveDiacritic int32
	FnException       int32
	FaiException      uintptr
	FaCategory        [32]uint8
}

type TUnicode61Tokenizer1

type TUnicode61Tokenizer1 = struct {
	FaTokenChar       [128]uint8
	FaFold            uintptr
	FnFold            int32
	FeRemoveDiacritic int32
	FnException       int32
	FaiException      uintptr
	FaCategory        [32]uint8
}

type TUnixUnusedFd

type TUnixUnusedFd = struct {
	Ffd    int32
	Fflags int32
	FpNext uintptr
}

An i-node

type TUnixUnusedFd1

type TUnixUnusedFd1 = struct {
	Ffd    int32
	Fflags int32
	FpNext uintptr
}

** Sometimes, after a file handle is closed by SQLite, the file descriptor ** cannot be closed immediately. In these cases, instances of the following ** structure are used to store the file descriptor while waiting for an ** opportunity to either close or reuse it.

type TUnpackedRecord

type TUnpackedRecord = struct {
	FpKeyInfo uintptr
	FaMem     uintptr
	Fu        struct {
		Fi [0]Ti64
		Fz uintptr
	}
	Fn          int32
	FnField     Tu16
	Fdefault_rc Ti8
	FerrCode    Tu8
	Fr1         Ti8
	Fr2         Ti8
	FeqSeen     Tu8
}

type TUnpackedRecord1

type TUnpackedRecord1 = struct {
	FpKeyInfo uintptr
	FaMem     uintptr
	Fu        struct {
		Fi [0]Ti64
		Fz uintptr
	}
	Fn          int32
	FnField     Tu16
	Fdefault_rc Ti8
	FerrCode    Tu8
	Fr1         Ti8
	Fr2         Ti8
	FeqSeen     Tu8
}

** This object holds a record which has been parsed out into individual ** fields, for the purposes of doing a comparison. ** ** A record is an object that contains one or more fields of data. ** Records are used to store the content of a table row and to store ** the key of an index. A blob encoding of a record is created by ** the OP_MakeRecord opcode of the VDBE and is disassembled by the ** OP_Column opcode. ** ** An instance of this object serves as a "key" for doing a search on ** an index b+tree. The goal of the search is to find the entry that ** is closed to the key described by this object. This object might hold ** just a prefix of the key. The number of fields is given by ** pKeyInfo->nField. ** ** The r1 and r2 fields are the values to return if this key is less than ** or greater than a key in the btree, respectively. These are normally ** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree ** is in DESC order. ** ** The key comparison functions actually return default_rc when they find ** an equals comparison. default_rc can be -1, 0, or +1. If there are ** multiple entries in the b-tree with the same key (when only looking ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to ** cause the search to find the last match, or +1 to cause the search to ** find the first match. ** ** The key comparison functions will set eqSeen to true if they ever ** get and equal results when comparing this structure to a b-tree record. ** When default_rc!=0, the search might end up on the record immediately ** before the first match or immediately after the last match. The ** eqSeen field will indicate whether or not an exact match exists in the ** b-tree.

type TUpsert

type TUpsert = struct {
	FpUpsertTarget      uintptr
	FpUpsertTargetWhere uintptr
	FpUpsertSet         uintptr
	FpUpsertWhere       uintptr
	FpNextUpsert        uintptr
	FisDoUpdate         Tu8
	FisDup              Tu8
	FpToFree            uintptr
	FpUpsertIdx         uintptr
	FpUpsertSrc         uintptr
	FregData            int32
	FiDataCur           int32
	FiIdxCur            int32
}

type TUpsert1

type TUpsert1 = struct {
	FpUpsertTarget      uintptr
	FpUpsertTargetWhere uintptr
	FpUpsertSet         uintptr
	FpUpsertWhere       uintptr
	FpNextUpsert        uintptr
	FisDoUpdate         Tu8
	FisDup              Tu8
	FpToFree            uintptr
	FpUpsertIdx         uintptr
	FpUpsertSrc         uintptr
	FregData            int32
	FiDataCur           int32
	FiIdxCur            int32
}

** An instance of the following object describes a single ON CONFLICT ** clause in an upsert. ** ** The pUpsertTarget field is only set if the ON CONFLICT clause includes ** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the ** conflict-target clause.) The pUpsertTargetWhere is the optional ** WHERE clause used to identify partial unique indexes. ** ** pUpsertSet is the list of column=expr terms of the UPDATE statement. ** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING. The ** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the ** WHERE clause is omitted.

type TVList

type TVList = int32

C documentation

/* A VList object records a mapping between parameters/variables/wildcards
** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
** variable number associated with that parameter.  See the format description
** on the sqlite3VListAdd() routine for more information.  A VList is really
** just an array of integers.
*/

type TVTable

type TVTable = struct {
	Fdb          uintptr
	FpMod        uintptr
	FpVtab       uintptr
	FnRef        int32
	FbConstraint Tu8
	FbAllSchemas Tu8
	FeVtabRisk   Tu8
	FiSavepoint  int32
	FpNext       uintptr
}

type TVTable1

type TVTable1 = struct {
	Fdb          uintptr
	FpMod        uintptr
	FpVtab       uintptr
	FnRef        int32
	FbConstraint Tu8
	FbAllSchemas Tu8
	FeVtabRisk   Tu8
	FiSavepoint  int32
	FpNext       uintptr
}

** An object of this type is created for each virtual table present in ** the database schema. ** ** If the database schema is shared, then there is one instance of this ** structure for each database connection (sqlite3*) that uses the shared ** schema. This is because each database connection requires its own unique ** instance of the sqlite3_vtab* handle used to access the virtual table ** implementation. sqlite3_vtab* handles can not be shared between ** database connections, even when the rest of the in-memory database ** schema is shared, as the implementation often stores the database ** connection handle passed to it via the xConnect() or xCreate() method ** during initialization internally. This database connection handle may ** then be used by the virtual table implementation to access real tables ** within the database. So that they appear as part of the callers ** transaction, these accesses need to be made via the same database ** connection as that used to execute SQL operations on the virtual table. ** ** All VTable objects that correspond to a single table in a shared ** database schema are initially stored in a linked-list pointed to by ** the Table.pVTable member variable of the corresponding Table object. ** When an sqlite3_prepare() operation is required to access the virtual ** table, it searches the list for the VTable that corresponds to the ** database connection doing the preparing so as to use the correct ** sqlite3_vtab* handle in the compiled query. ** ** When an in-memory Table object is deleted (for example when the ** schema is being reloaded for some reason), the VTable objects are not ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed ** immediately. Instead, they are moved from the Table.pVTable list to ** another linked list headed by the sqlite3.pDisconnect member of the ** corresponding sqlite3 structure. They are then deleted/xDisconnected ** next time a statement is prepared using said sqlite3*. This is done ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. ** Refer to comments above function sqlite3VtabUnlockList() for an ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect ** list without holding the corresponding sqlite3.mutex mutex. ** ** The memory for objects of this type is always allocated by ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as ** the first argument.

type TValueList

type TValueList = struct {
	FpCsr uintptr
	FpOut uintptr
}

C documentation

/*
** An instance of this object is used to pass an vector of values into
** OP_VFilter, the xFilter method of a virtual table.  The vector is the
** set of values on the right-hand side of an IN constraint.
**
** The value as passed into xFilter is an sqlite3_value with a "pointer"
** type, such as is generated by sqlite3_result_pointer() and read by
** sqlite3_value_pointer.  Such values have MEM_Term|MEM_Subtype|MEM_Null
** and a subtype of 'p'.  The sqlite3_vtab_in_first() and _next() interfaces
** know how to use this object to step through all the values in the
** right operand of the IN constraint.
*/

type TValueList1

type TValueList1 = struct {
	FpCsr uintptr
	FpOut uintptr
}

type TValueNewStat4Ctx

type TValueNewStat4Ctx = struct {
	FpParse uintptr
	FpIdx   uintptr
	FppRec  uintptr
	FiVal   int32
}

** Context object passed by sqlite3Stat4ProbeSetValue() through to ** valueNew(). See comments above valueNew() for details.

type TVdbe

type TVdbe = struct {
	Fdb                 uintptr
	FppVPrev            uintptr
	FpVNext             uintptr
	FpParse             uintptr
	FnVar               TynVar
	FnMem               int32
	FnCursor            int32
	FcacheCtr           Tu32
	Fpc                 int32
	Frc                 int32
	FnChange            Ti64
	FiStatement         int32
	FiCurrentTime       Ti64
	FnFkConstraint      Ti64
	FnStmtDefCons       Ti64
	FnStmtDefImmCons    Ti64
	FaMem               uintptr
	FapArg              uintptr
	FapCsr              uintptr
	FaVar               uintptr
	FaOp                uintptr
	FnOp                int32
	FnOpAlloc           int32
	FaColName           uintptr
	FpResultRow         uintptr
	FzErrMsg            uintptr
	FpVList             uintptr
	FstartTime          Ti64
	FnResColumn         Tu16
	FnResAlloc          Tu16
	FerrorAction        Tu8
	FminWriteFileFormat Tu8
	FprepFlags          Tu8
	FeVdbeState         Tu8
	F__ccgo200          uint16
	FbtreeMask          TyDbMask
	FlockMask           TyDbMask
	FaCounter           [9]Tu32
	FzSql               uintptr
	FpFree              uintptr
	FpFrame             uintptr
	FpDelFrame          uintptr
	FnFrame             int32
	Fexpmask            Tu32
	FpProgram           uintptr
	FpAuxData           uintptr
}

C documentation

/*
** A single VDBE is an opaque structure named "Vdbe".  Only routines
** in the source file sqliteVdbe.c are allowed to see the insides
** of this structure.
*/

type TVdbe1

type TVdbe1 = struct {
	Fdb                 uintptr
	FppVPrev            uintptr
	FpVNext             uintptr
	FpParse             uintptr
	FnVar               TynVar
	FnMem               int32
	FnCursor            int32
	FcacheCtr           Tu32
	Fpc                 int32
	Frc                 int32
	FnChange            Ti64
	FiStatement         int32
	FiCurrentTime       Ti64
	FnFkConstraint      Ti64
	FnStmtDefCons       Ti64
	FnStmtDefImmCons    Ti64
	FaMem               uintptr
	FapArg              uintptr
	FapCsr              uintptr
	FaVar               uintptr
	FaOp                uintptr
	FnOp                int32
	FnOpAlloc           int32
	FaColName           uintptr
	FpResultRow         uintptr
	FzErrMsg            uintptr
	FpVList             uintptr
	FstartTime          Ti64
	FnResColumn         Tu16
	FnResAlloc          Tu16
	FerrorAction        Tu8
	FminWriteFileFormat Tu8
	FprepFlags          Tu8
	FeVdbeState         Tu8
	F__ccgo200          uint16
	FbtreeMask          TyDbMask
	FlockMask           TyDbMask
	FaCounter           [9]Tu32
	FzSql               uintptr
	FpFree              uintptr
	FpFrame             uintptr
	FpDelFrame          uintptr
	FnFrame             int32
	Fexpmask            Tu32
	FpProgram           uintptr
	FpAuxData           uintptr
}

** An instance of the virtual machine. This structure contains the complete ** state of the virtual machine. ** ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare() ** is really a pointer to an instance of this structure.

type TVdbeCursor

type TVdbeCursor = struct {
	FeCurType       Tu8
	FiDb            Ti8
	FnullRow        Tu8
	FdeferredMoveto Tu8
	FisTable        Tu8
	F__ccgo_align5  [3]byte
	F__ccgo8        uint8
	FseekHit        Tu16
	Fub             struct {
		FaAltMap [0]uintptr
		FpBtx    uintptr
	}
	FseqCount    Ti64
	FcacheStatus Tu32
	FseekResult  int32
	FpAltCursor  uintptr
	Fuc          struct {
		FpVCur   [0]uintptr
		FpSorter [0]uintptr
		FpCursor uintptr
	}
	FpKeyInfo     uintptr
	FiHdrOffset   Tu32
	FpgnoRoot     TPgno
	FnField       Ti16
	FnHdrParsed   Tu16
	FmovetoTarget Ti64
	FaOffset      uintptr
	FaRow         uintptr
	FpayloadSize  Tu32
	FszRow        Tu32
	FpCache       uintptr
	FaType        [1]Tu32
}

C documentation

/*
** A VdbeCursor is an superclass (a wrapper) for various cursor objects:
**
**      * A b-tree cursor
**          -  In the main database or in an ephemeral database
**          -  On either an index or a table
**      * A sorter
**      * A virtual table
**      * A one-row "pseudotable" stored in a single register
*/

type TVdbeCursor1

type TVdbeCursor1 = struct {
	FeCurType       Tu8
	FiDb            Ti8
	FnullRow        Tu8
	FdeferredMoveto Tu8
	FisTable        Tu8
	F__ccgo_align5  [3]byte
	F__ccgo8        uint8
	FseekHit        Tu16
	Fub             struct {
		FaAltMap [0]uintptr
		FpBtx    uintptr
	}
	FseqCount    Ti64
	FcacheStatus Tu32
	FseekResult  int32
	FpAltCursor  uintptr
	Fuc          struct {
		FpVCur   [0]uintptr
		FpSorter [0]uintptr
		FpCursor uintptr
	}
	FpKeyInfo     uintptr
	FiHdrOffset   Tu32
	FpgnoRoot     TPgno
	FnField       Ti16
	FnHdrParsed   Tu16
	FmovetoTarget Ti64
	FaOffset      uintptr
	FaRow         uintptr
	FpayloadSize  Tu32
	FszRow        Tu32
	FpCache       uintptr
	FaType        [1]Tu32
}

type TVdbeFrame

type TVdbeFrame = struct {
	Fv         uintptr
	FpParent   uintptr
	FaOp       uintptr
	FaMem      uintptr
	FapCsr     uintptr
	FaOnce     uintptr
	Ftoken     uintptr
	FlastRowid Ti64
	FpAuxData  uintptr
	FnCursor   int32
	Fpc        int32
	FnOp       int32
	FnMem      int32
	FnChildMem int32
	FnChildCsr int32
	FnChange   Ti64
	FnDbChange Ti64
}

C documentation

/*
** When a sub-program is executed (OP_Program), a structure of this type
** is allocated to store the current value of the program counter, as
** well as the current memory cell array and various other frame specific
** values stored in the Vdbe struct. When the sub-program is finished,
** these values are copied back to the Vdbe from the VdbeFrame structure,
** restoring the state of the VM to as it was before the sub-program
** began executing.
**
** The memory for a VdbeFrame object is allocated and managed by a memory
** cell in the parent (calling) frame. When the memory cell is deleted or
** overwritten, the VdbeFrame object is not freed immediately. Instead, it
** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
** this instead of deleting the VdbeFrame immediately is to avoid recursive
** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
** child frame are released.
**
** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
** set to NULL if the currently executing frame is the main program.
*/

type TVdbeFrame1

type TVdbeFrame1 = struct {
	Fv         uintptr
	FpParent   uintptr
	FaOp       uintptr
	FaMem      uintptr
	FapCsr     uintptr
	FaOnce     uintptr
	Ftoken     uintptr
	FlastRowid Ti64
	FpAuxData  uintptr
	FnCursor   int32
	Fpc        int32
	FnOp       int32
	FnMem      int32
	FnChildMem int32
	FnChildCsr int32
	FnChange   Ti64
	FnDbChange Ti64
}

type TVdbeOp

type TVdbeOp = struct {
	Fopcode Tu8
	Fp4type int8
	Fp5     Tu16
	Fp1     int32
	Fp2     int32
	Fp3     int32
	Fp4     Tp4union
}

type TVdbeOp1

type TVdbeOp1 = struct {
	Fopcode Tu8
	Fp4type int8
	Fp5     Tu16
	Fp1     int32
	Fp2     int32
	Fp3     int32
	Fp4     Tp4union
}

** A single instruction of the virtual machine has an opcode ** and as many as three operands. The instruction is recorded ** as an instance of the following structure:

type TVdbeOpList

type TVdbeOpList = struct {
	Fopcode Tu8
	Fp1     int8
	Fp2     int8
	Fp3     int8
}

type TVdbeOpList1

type TVdbeOpList1 = struct {
	Fopcode Tu8
	Fp1     int8
	Fp2     int8
	Fp3     int8
}

** A smaller version of VdbeOp used for the VdbeAddOpList() function because ** it takes up less space.

type TVdbeSorter

type TVdbeSorter = struct {
	FmnPmaSize   int32
	FmxPmaSize   int32
	FmxKeysize   int32
	Fpgsz        int32
	FpReader     uintptr
	FpMerger     uintptr
	Fdb          uintptr
	FpKeyInfo    uintptr
	FpUnpacked   uintptr
	Flist        TSorterList
	FiMemory     int32
	FnMemory     int32
	FbUsePMA     Tu8
	FbUseThreads Tu8
	FiPrev       Tu8
	FnTask       Tu8
	FtypeMask    Tu8
	FaTask       [1]TSortSubtask
}

C documentation

/* Opaque type used by code in vdbesort.c */

type TVdbeSorter1

type TVdbeSorter1 = struct {
	FmnPmaSize   int32
	FmxPmaSize   int32
	FmxKeysize   int32
	Fpgsz        int32
	FpReader     uintptr
	FpMerger     uintptr
	Fdb          uintptr
	FpKeyInfo    uintptr
	FpUnpacked   uintptr
	Flist        TSorterList
	FiMemory     int32
	FnMemory     int32
	FbUsePMA     Tu8
	FbUseThreads Tu8
	FiPrev       Tu8
	FnTask       Tu8
	FtypeMask    Tu8
	FaTask       [1]TSortSubtask
}

** Main sorter structure. A single instance of this is allocated for each ** sorter cursor created by the VDBE. ** ** mxKeysize: ** As records are added to the sorter by calls to sqlite3VdbeSorterWrite(), ** this variable is updated so as to be set to the size on disk of the ** largest record in the sorter.

type TVdbeTxtBlbCache

type TVdbeTxtBlbCache = struct {
	FpCValue     uintptr
	FiOffset     Ti64
	FiCol        int32
	FcacheStatus Tu32
	FcolCacheCtr Tu32
}

C documentation

/* A cache of large TEXT or BLOB values in a VdbeCursor */

type TVdbeTxtBlbCache1

type TVdbeTxtBlbCache1 = struct {
	FpCValue     uintptr
	FiOffset     Ti64
	FiCol        int32
	FcacheStatus Tu32
	FcolCacheCtr Tu32
}

** Large TEXT or BLOB values can be slow to load, so we want to avoid ** loading them more than once. For that reason, large TEXT and BLOB values ** can be stored in a cache defined by this object, and attached to the ** VdbeCursor using the pCache field.

type TVtabCtx

type TVtabCtx = struct {
	FpVTable   uintptr
	FpTab      uintptr
	FpPrior    uintptr
	FbDeclared int32
}

type TVtabCtx1

type TVtabCtx1 = struct {
	FpVTable   uintptr
	FpTab      uintptr
	FpPrior    uintptr
	FbDeclared int32
}

** Before a virtual table xCreate() or xConnect() method is invoked, the ** sqlite3.pVtabCtx member variable is set to point to an instance of ** this struct allocated on the stack. It is used by the implementation of ** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which ** are invoked only from within xCreate and xConnect methods.

type TWal

type TWal = struct {
	FpVfs                uintptr
	FpDbFd               uintptr
	FpWalFd              uintptr
	FiCallback           Tu32
	FmxWalSize           Ti64
	FnWiData             int32
	FszFirstBlock        int32
	FapWiData            uintptr
	FszPage              Tu32
	FreadLock            Ti16
	FsyncFlags           Tu8
	FexclusiveMode       Tu8
	FwriteLock           Tu8
	FckptLock            Tu8
	FreadOnly            Tu8
	FtruncateOnCommit    Tu8
	FsyncHeader          Tu8
	FpadToSectorBoundary Tu8
	FbShmUnreliable      Tu8
	Fhdr                 TWalIndexHdr
	FminFrame            Tu32
	FiReCksum            Tu32
	FzWalName            uintptr
	FnCkpt               Tu32
	FpSnapshot           uintptr
}

C documentation

/* Connection to a write-ahead log (WAL) file.
** There is one object of this type for each pager.
*/

type TWal1

type TWal1 = struct {
	FpVfs                uintptr
	FpDbFd               uintptr
	FpWalFd              uintptr
	FiCallback           Tu32
	FmxWalSize           Ti64
	FnWiData             int32
	FszFirstBlock        int32
	FapWiData            uintptr
	FszPage              Tu32
	FreadLock            Ti16
	FsyncFlags           Tu8
	FexclusiveMode       Tu8
	FwriteLock           Tu8
	FckptLock            Tu8
	FreadOnly            Tu8
	FtruncateOnCommit    Tu8
	FsyncHeader          Tu8
	FpadToSectorBoundary Tu8
	FbShmUnreliable      Tu8
	Fhdr                 TWalIndexHdr
	FminFrame            Tu32
	FiReCksum            Tu32
	FzWalName            uintptr
	FnCkpt               Tu32
	FpSnapshot           uintptr
}

** An open write-ahead log file is represented by an instance of the ** following object.

type TWalCkptInfo

type TWalCkptInfo = struct {
	FnBackfill          Tu32
	FaReadMark          [5]Tu32
	FaLock              [8]Tu8
	FnBackfillAttempted Tu32
	FnotUsed0           Tu32
}

type TWalCkptInfo1

type TWalCkptInfo1 = struct {
	FnBackfill          Tu32
	FaReadMark          [5]Tu32
	FaLock              [8]Tu8
	FnBackfillAttempted Tu32
	FnotUsed0           Tu32
}

** A copy of the following object occurs in the wal-index immediately ** following the second copy of the WalIndexHdr. This object stores ** information used by checkpoint. ** ** nBackfill is the number of frames in the WAL that have been written ** back into the database. (We call the act of moving content from WAL to ** database "backfilling".) The nBackfill number is never greater than ** WalIndexHdr.mxFrame. nBackfill can only be increased by threads ** holding the WAL_CKPT_LOCK lock (which includes a recovery thread). ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from ** mxFrame back to zero when the WAL is reset. ** ** nBackfillAttempted is the largest value of nBackfill that a checkpoint ** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however ** the nBackfillAttempted is set before any backfilling is done and the ** nBackfill is only set after all backfilling completes. So if a checkpoint ** crashes, nBackfillAttempted might be larger than nBackfill. The ** WalIndexHdr.mxFrame must never be less than nBackfillAttempted. ** ** The aLock[] field is a set of bytes used for locking. These bytes should ** never be read or written. ** ** There is one entry in aReadMark[] for each reader lock. If a reader ** holds read-lock K, then the value in aReadMark[K] is no greater than ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff) ** for any aReadMark[] means that entry is unused. aReadMark[0] is ** a special case; its value is never used and it exists as a place-holder ** to avoid having to offset aReadMark[] indexes by one. Readers holding ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content ** directly from the database. ** ** The value of aReadMark[K] may only be changed by a thread that ** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of ** aReadMark[K] cannot changed while there is a reader is using that mark ** since the reader will be holding a shared lock on WAL_READ_LOCK(K). ** ** The checkpointer may only transfer frames from WAL to database where ** the frame numbers are less than or equal to every aReadMark[] that is ** in use (that is, every aReadMark[j] for which there is a corresponding ** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the ** largest value and will increase an unused aReadMark[] to mxFrame if there ** is not already an aReadMark[] equal to mxFrame. The exception to the ** previous sentence is when nBackfill equals mxFrame (meaning that everything ** in the WAL has been backfilled into the database) then new readers ** will choose aReadMark[0] which has value 0 and hence such reader will ** get all their all content directly from the database file and ignore ** the WAL. ** ** Writers normally append new frames to the end of the WAL. However, ** if nBackfill equals mxFrame (meaning that all WAL content has been ** written back into the database) and if no readers are using the WAL ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then ** the writer will first "reset" the WAL back to the beginning and start ** writing new content beginning at frame 1. ** ** We assume that 32-bit loads are atomic and so no locks are needed in ** order to read from any aReadMark[] entries.

type TWalHashLoc

type TWalHashLoc = struct {
	FaHash uintptr
	FaPgno uintptr
	FiZero Tu32
}

C documentation

/*
** An instance of the WalHashLoc object is used to describe the location
** of a page hash table in the wal-index.  This becomes the return value
** from walHashGet().
*/

type TWalHashLoc1

type TWalHashLoc1 = struct {
	FaHash uintptr
	FaPgno uintptr
	FiZero Tu32
}

type TWalIndexHdr

type TWalIndexHdr = struct {
	FiVersion    Tu32
	Funused      Tu32
	FiChange     Tu32
	FisInit      Tu8
	FbigEndCksum Tu8
	FszPage      Tu16
	FmxFrame     Tu32
	FnPage       Tu32
	FaFrameCksum [2]Tu32
	FaSalt       [2]Tu32
	FaCksum      [2]Tu32
}

C documentation

/* Object declarations */

type TWalIndexHdr1

type TWalIndexHdr1 = struct {
	FiVersion    Tu32
	Funused      Tu32
	FiChange     Tu32
	FisInit      Tu8
	FbigEndCksum Tu8
	FszPage      Tu16
	FmxFrame     Tu32
	FnPage       Tu32
	FaFrameCksum [2]Tu32
	FaSalt       [2]Tu32
	FaCksum      [2]Tu32
}

** The following object holds a copy of the wal-index header content. ** ** The actual header in the wal-index consists of two copies of this ** object followed by one instance of the WalCkptInfo object. ** For all versions of SQLite through 3.10.0 and probably beyond, ** the locking bytes (WalCkptInfo.aLock) start at offset 120 and ** the total header size is 136 bytes. ** ** The szPage value can be any power of 2 between 512 and 32768, inclusive. ** Or it can be 1 to represent a 65536-byte page. The latter case was ** added in 3.7.1 when support for 64K pages was added.

type TWalIterator

type TWalIterator = struct {
	FiPrior   Tu32
	FnSegment int32
	FaSegment [1]TWalSegment
}

type TWalIterator1

type TWalIterator1 = struct {
	FiPrior   Tu32
	FnSegment int32
	FaSegment [1]TWalSegment
}

** This structure is used to implement an iterator that loops through ** all frames in the WAL in database page order. Where two or more frames ** correspond to the same database page, the iterator visits only the ** frame most recently written to the WAL (in other words, the frame with ** the largest index). ** ** The internals of this structure are only accessed by: ** ** walIteratorInit() - Create a new iterator, ** walIteratorNext() - Step an iterator, ** walIteratorFree() - Free an iterator. ** ** This functionality is used by the checkpoint code (see walCheckpoint()).

type TWalSegment

type TWalSegment = struct {
	FiNext  int32
	FaIndex uintptr
	FaPgno  uintptr
	FnEntry int32
	FiZero  int32
}

type TWalWriter

type TWalWriter = struct {
	FpWal       uintptr
	FpFd        uintptr
	FiSyncPoint Tsqlite3_int64
	FsyncFlags  int32
	FszPage     int32
}

C documentation

/*
** Information about the current state of the WAL file and where
** the next fsync should occur - passed from sqlite3WalFrames() into
** walWriteToLog().
*/

type TWalker

type TWalker = struct {
	FpParse           uintptr
	FxExprCallback    uintptr
	FxSelectCallback  uintptr
	FxSelectCallback2 uintptr
	FwalkerDepth      int32
	FeCode            Tu16
	FmWFlags          Tu16
	Fu                struct {
		Fn           [0]int32
		FiCur        [0]int32
		FpSrcList    [0]uintptr
		FpCCurHint   [0]uintptr
		FpRefSrcList [0]uintptr
		FaiCol       [0]uintptr
		FpIdxCover   [0]uintptr
		FpGroupBy    [0]uintptr
		FpSelect     [0]uintptr
		FpRewrite    [0]uintptr
		FpConst      [0]uintptr
		FpRename     [0]uintptr
		FpTab        [0]uintptr
		FpCovIdxCk   [0]uintptr
		FpSrcItem    [0]uintptr
		FpFix        [0]uintptr
		FaMem        [0]uintptr
		FpNC         uintptr
	}
}

type TWalker1

type TWalker1 = struct {
	FpParse           uintptr
	FxExprCallback    uintptr
	FxSelectCallback  uintptr
	FxSelectCallback2 uintptr
	FwalkerDepth      int32
	FeCode            Tu16
	FmWFlags          Tu16
	Fu                struct {
		Fn           [0]int32
		FiCur        [0]int32
		FpSrcList    [0]uintptr
		FpCCurHint   [0]uintptr
		FpRefSrcList [0]uintptr
		FaiCol       [0]uintptr
		FpIdxCover   [0]uintptr
		FpGroupBy    [0]uintptr
		FpSelect     [0]uintptr
		FpRewrite    [0]uintptr
		FpConst      [0]uintptr
		FpRename     [0]uintptr
		FpTab        [0]uintptr
		FpCovIdxCk   [0]uintptr
		FpSrcItem    [0]uintptr
		FpFix        [0]uintptr
		FaMem        [0]uintptr
		FpNC         uintptr
	}
}

** Context pointer passed down through the tree-walk.

type TWhereAndInfo

type TWhereAndInfo = struct {
	Fwc TWhereClause
}

type TWhereAndInfo1

type TWhereAndInfo1 = struct {
	Fwc TWhereClause
}

** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to ** a dynamically allocated instance of the following structure.

type TWhereClause

type TWhereClause = struct {
	FpWInfo  uintptr
	FpOuter  uintptr
	Fop      Tu8
	FhasOr   Tu8
	FnTerm   int32
	FnSlot   int32
	FnBase   int32
	Fa       uintptr
	FaStatic [8]TWhereTerm
}

C documentation

/* Forward references
*/

type TWhereClause1

type TWhereClause1 = struct {
	FpWInfo  uintptr
	FpOuter  uintptr
	Fop      Tu8
	FhasOr   Tu8
	FnTerm   int32
	FnSlot   int32
	FnBase   int32
	Fa       uintptr
	FaStatic [8]TWhereTerm
}

** An instance of the following structure holds all information about a ** WHERE clause. Mostly this is a container for one or more WhereTerms. ** ** Explanation of pOuter: For a WHERE clause of the form ** ** a AND ((b AND c) OR (d AND e)) AND f ** ** There are separate WhereClause objects for the whole clause and for ** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the ** subclauses points to the WhereClause object for the whole clause.

type TWhereConst

type TWhereConst = struct {
	FpParse      uintptr
	FpOomFault   uintptr
	FnConst      int32
	FnChng       int32
	FbHasAffBlob int32
	FmExcludeOn  Tu32
	FapExpr      uintptr
}

C documentation

/*
** A structure to keep track of all of the column values that are fixed to
** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
*/

type TWhereConst1

type TWhereConst1 = struct {
	FpParse      uintptr
	FpOomFault   uintptr
	FnConst      int32
	FnChng       int32
	FbHasAffBlob int32
	FmExcludeOn  Tu32
	FapExpr      uintptr
}

type TWhereInfo

type TWhereInfo = struct {
	FpParse          uintptr
	FpTabList        uintptr
	FpOrderBy        uintptr
	FpResultSet      uintptr
	FpSelect         uintptr
	FaiCurOnePass    [2]int32
	FiContinue       int32
	FiBreak          int32
	FsavedNQueryLoop int32
	FwctrlFlags      Tu16
	FiLimit          TLogEst
	FnLevel          Tu8
	FnOBSat          Ti8
	FeOnePass        Tu8
	FeDistinct       Tu8
	F__ccgo68        uint8
	FnRowOut         TLogEst
	FiTop            int32
	FiEndWhere       int32
	FpLoops          uintptr
	FpMemToFree      uintptr
	FrevMask         TBitmask
	FsWC             TWhereClause
	FsMaskSet        TWhereMaskSet
	Fa               [1]TWhereLevel
}

type TWhereInfo1

type TWhereInfo1 = struct {
	FpParse          uintptr
	FpTabList        uintptr
	FpOrderBy        uintptr
	FpResultSet      uintptr
	FpSelect         uintptr
	FaiCurOnePass    [2]int32
	FiContinue       int32
	FiBreak          int32
	FsavedNQueryLoop int32
	FwctrlFlags      Tu16
	FiLimit          TLogEst
	FnLevel          Tu8
	FnOBSat          Ti8
	FeOnePass        Tu8
	FeDistinct       Tu8
	F__ccgo68        uint8
	FnRowOut         TLogEst
	FiTop            int32
	FiEndWhere       int32
	FpLoops          uintptr
	FpMemToFree      uintptr
	FrevMask         TBitmask
	FsWC             TWhereClause
	FsMaskSet        TWhereMaskSet
	Fa               [1]TWhereLevel
}

** The WHERE clause processing routine has two halves. The ** first part does the start of the WHERE loop and the second ** half does the tail of the WHERE loop. An instance of ** this structure is returned by the first half and passed ** into the second half to give some continuity. ** ** An instance of this object holds the complete state of the query ** planner.

type TWhereLevel

type TWhereLevel = struct {
	FiLeftJoin   int32
	FiTabCur     int32
	FiIdxCur     int32
	FaddrBrk     int32
	FaddrNxt     int32
	FaddrSkip    int32
	FaddrCont    int32
	FaddrFirst   int32
	FaddrBody    int32
	FregBignull  int32
	FaddrBignull int32
	FregFilter   int32
	FpRJ         uintptr
	FiFrom       Tu8
	Fop          Tu8
	Fp3          Tu8
	Fp5          Tu8
	Fp1          int32
	Fp2          int32
	Fu           struct {
		FpCoveringIdx [0]uintptr
		Fin           struct {
			FnIn     int32
			FaInLoop uintptr
		}
	}
	FpWLoop   uintptr
	FnotReady TBitmask
}

type TWhereLevel1

type TWhereLevel1 = struct {
	FiLeftJoin   int32
	FiTabCur     int32
	FiIdxCur     int32
	FaddrBrk     int32
	FaddrNxt     int32
	FaddrSkip    int32
	FaddrCont    int32
	FaddrFirst   int32
	FaddrBody    int32
	FregBignull  int32
	FaddrBignull int32
	FregFilter   int32
	FpRJ         uintptr
	FiFrom       Tu8
	Fop          Tu8
	Fp3          Tu8
	Fp5          Tu8
	Fp1          int32
	Fp2          int32
	Fu           struct {
		FpCoveringIdx [0]uintptr
		Fin           struct {
			FnIn     int32
			FaInLoop uintptr
		}
	}
	FpWLoop   uintptr
	FnotReady TBitmask
}

** This object contains information needed to implement a single nested ** loop in WHERE clause. ** ** Contrast this object with WhereLoop. This object describes the ** implementation of the loop. WhereLoop describes the algorithm. ** This object contains a pointer to the WhereLoop algorithm as one of ** its elements. ** ** The WhereInfo object contains a single instance of this object for ** each term in the FROM clause (which is to say, for each of the ** nested loops as implemented). The order of WhereLevel objects determines ** the loop nested order, with WhereInfo.a[0] being the outer loop and ** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop.

type TWhereLoop

type TWhereLoop = struct {
	Fprereq   TBitmask
	FmaskSelf TBitmask
	FiTab     Tu8
	FiSortIdx Tu8
	FrSetup   TLogEst
	FrRun     TLogEst
	FnOut     TLogEst
	Fu        struct {
		Fvtab [0]struct {
			FidxNum    int32
			F__ccgo4   uint8
			FisOrdered Ti8
			FomitMask  Tu16
			FidxStr    uintptr
			FmHandleIn Tu32
		}
		Fbtree struct {
			FnEq          Tu16
			FnBtm         Tu16
			FnTop         Tu16
			FnDistinctCol Tu16
			FpIndex       uintptr
		}
		F__ccgo_pad2 [8]byte
	}
	FwsFlags     Tu32
	FnLTerm      Tu16
	FnSkip       Tu16
	FnLSlot      Tu16
	FaLTerm      uintptr
	FpNextLoop   uintptr
	FaLTermSpace [3]uintptr
}

type TWhereLoop1

type TWhereLoop1 = struct {
	Fprereq   TBitmask
	FmaskSelf TBitmask
	FiTab     Tu8
	FiSortIdx Tu8
	FrSetup   TLogEst
	FrRun     TLogEst
	FnOut     TLogEst
	Fu        struct {
		Fvtab [0]struct {
			FidxNum    int32
			F__ccgo4   uint8
			FisOrdered Ti8
			FomitMask  Tu16
			FidxStr    uintptr
			FmHandleIn Tu32
		}
		Fbtree struct {
			FnEq          Tu16
			FnBtm         Tu16
			FnTop         Tu16
			FnDistinctCol Tu16
			FpIndex       uintptr
		}
		F__ccgo_pad2 [8]byte
	}
	FwsFlags     Tu32
	FnLTerm      Tu16
	FnSkip       Tu16
	FnLSlot      Tu16
	FaLTerm      uintptr
	FpNextLoop   uintptr
	FaLTermSpace [3]uintptr
}

** Each instance of this object represents an algorithm for evaluating one ** term of a join. Every term of the FROM clause will have at least ** one corresponding WhereLoop object (unless INDEXED BY constraints ** prevent a query solution - which is an error) and many terms of the ** FROM clause will have multiple WhereLoop objects, each describing a ** potential way of implementing that FROM-clause term, together with ** dependencies and cost estimates for using the chosen algorithm. ** ** Query planning consists of building up a collection of these WhereLoop ** objects, then computing a particular sequence of WhereLoop objects, with ** one WhereLoop object per FROM clause term, that satisfy all dependencies ** and that minimize the overall cost.

type TWhereLoopBuilder

type TWhereLoopBuilder = struct {
	FpWInfo     uintptr
	FpWC        uintptr
	FpNew       uintptr
	FpOrSet     uintptr
	FpRec       uintptr
	FnRecValid  int32
	FbldFlags1  uint8
	FbldFlags2  uint8
	FiPlanLimit uint32
}

type TWhereLoopBuilder1

type TWhereLoopBuilder1 = struct {
	FpWInfo     uintptr
	FpWC        uintptr
	FpNew       uintptr
	FpOrSet     uintptr
	FpRec       uintptr
	FnRecValid  int32
	FbldFlags1  uint8
	FbldFlags2  uint8
	FiPlanLimit uint32
}

** This object is a convenience wrapper holding all information needed ** to construct WhereLoop objects for a particular query.

type TWhereMaskSet

type TWhereMaskSet = struct {
	FbVarSelect int32
	Fn          int32
	Fix         [64]int32
}

type TWhereMaskSet1

type TWhereMaskSet1 = struct {
	FbVarSelect int32
	Fn          int32
	Fix         [64]int32
}

** An instance of the following structure keeps track of a mapping ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm. ** ** The VDBE cursor numbers are small integers contained in ** SrcItem.iCursor and Expr.iTable fields. For any given WHERE ** clause, the cursor numbers might not begin with 0 and they might ** contain gaps in the numbering sequence. But we want to make maximum ** use of the bits in our bitmasks. This structure provides a mapping ** from the sparse cursor numbers into consecutive integers beginning ** with 0. ** ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A. ** ** For example, if the WHERE clause expression used these VDBE ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure ** would map those cursor numbers into bits 0 through 5. ** ** Note that the mapping is not necessarily ordered. In the example ** above, the mapping might go like this: 4->3, 5->1, 8->2, 29->0, ** 57->5, 73->4. Or one of 719 other combinations might be used. It ** does not really matter. What is important is that sparse cursor ** numbers all get mapped into bit numbers that begin with 0 and contain ** no gaps.

type TWhereMemBlock

type TWhereMemBlock = struct {
	FpNext uintptr
	Fsz    Tu64
}

type TWhereMemBlock1

type TWhereMemBlock1 = struct {
	FpNext uintptr
	Fsz    Tu64
}

** This object is a header on a block of allocated memory that will be ** automatically freed when its WInfo object is destructed.

type TWhereOrCost

type TWhereOrCost = struct {
	Fprereq TBitmask
	FrRun   TLogEst
	FnOut   TLogEst
}

type TWhereOrCost1

type TWhereOrCost1 = struct {
	Fprereq TBitmask
	FrRun   TLogEst
	FnOut   TLogEst
}

This object holds the prerequisites and the cost of running a

** subquery on one operand of an OR operator in the WHERE clause. ** See WhereOrSet for additional information

type TWhereOrInfo

type TWhereOrInfo = struct {
	Fwc        TWhereClause
	Findexable TBitmask
}

type TWhereOrInfo1

type TWhereOrInfo1 = struct {
	Fwc        TWhereClause
	Findexable TBitmask
}

** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to ** a dynamically allocated instance of the following structure.

type TWhereOrSet

type TWhereOrSet = struct {
	Fn Tu16
	Fa [3]TWhereOrCost
}

type TWhereOrSet1

type TWhereOrSet1 = struct {
	Fn Tu16
	Fa [3]TWhereOrCost
}

The WhereOrSet object holds a set of possible WhereOrCosts that

** correspond to the subquery(s) of OR-clause processing. Only the ** best N_OR_COST elements are retained.

type TWherePath

type TWherePath = struct {
	FmaskLoop  TBitmask
	FrevLoop   TBitmask
	FnRow      TLogEst
	FrCost     TLogEst
	FrUnsorted TLogEst
	FisOrdered Ti8
	FaLoop     uintptr
}

type TWherePath1

type TWherePath1 = struct {
	FmaskLoop  TBitmask
	FrevLoop   TBitmask
	FnRow      TLogEst
	FrCost     TLogEst
	FrUnsorted TLogEst
	FisOrdered Ti8
	FaLoop     uintptr
}

** Each instance of this object holds a sequence of WhereLoop objects ** that implement some or all of a query plan. ** ** Think of each WhereLoop object as a node in a graph with arcs ** showing dependencies and costs for travelling between nodes. (That is ** not a completely accurate description because WhereLoop costs are a ** vector, not a scalar, and because dependencies are many-to-one, not ** one-to-one as are graph nodes. But it is a useful visualization aid.) ** Then a WherePath object is a path through the graph that visits some ** or all of the WhereLoop objects once. ** ** The "solver" works by creating the N best WherePath objects of length ** 1. Then using those as a basis to compute the N best WherePath objects ** of length 2. And so forth until the length of WherePaths equals the ** number of nodes in the FROM clause. The best (lowest cost) WherePath ** at the end is the chosen query plan.

type TWhereRightJoin

type TWhereRightJoin = struct {
	FiMatch     int32
	FregBloom   int32
	FregReturn  int32
	FaddrSubrtn int32
	FendSubrtn  int32
}

type TWhereRightJoin1

type TWhereRightJoin1 = struct {
	FiMatch     int32
	FregBloom   int32
	FregReturn  int32
	FaddrSubrtn int32
	FendSubrtn  int32
}

** Extra information attached to a WhereLevel that is a RIGHT JOIN.

type TWhereScan

type TWhereScan = struct {
	FpOrigWC   uintptr
	FpWC       uintptr
	FzCollName uintptr
	FpIdxExpr  uintptr
	Fk         int32
	FopMask    Tu32
	Fidxaff    int8
	FiEquiv    uint8
	FnEquiv    uint8
	FaiCur     [11]int32
	FaiColumn  [11]Ti16
}

type TWhereScan1

type TWhereScan1 = struct {
	FpOrigWC   uintptr
	FpWC       uintptr
	FzCollName uintptr
	FpIdxExpr  uintptr
	Fk         int32
	FopMask    Tu32
	Fidxaff    int8
	FiEquiv    uint8
	FnEquiv    uint8
	FaiCur     [11]int32
	FaiColumn  [11]Ti16
}

** An instance of the WhereScan object is used as an iterator for locating ** terms in the WHERE clause that are useful to the query planner.

type TWhereTerm

type TWhereTerm = struct {
	FpExpr      uintptr
	FpWC        uintptr
	FtruthProb  TLogEst
	FwtFlags    Tu16
	FeOperator  Tu16
	FnChild     Tu8
	FeMatchOp   Tu8
	FiParent    int32
	FleftCursor int32
	Fu          struct {
		FpOrInfo  [0]uintptr
		FpAndInfo [0]uintptr
		Fx        struct {
			FleftColumn int32
			FiField     int32
		}
	}
	FprereqRight TBitmask
	FprereqAll   TBitmask
}

type TWhereTerm1

type TWhereTerm1 = struct {
	FpExpr      uintptr
	FpWC        uintptr
	FtruthProb  TLogEst
	FwtFlags    Tu16
	FeOperator  Tu16
	FnChild     Tu8
	FeMatchOp   Tu8
	FiParent    int32
	FleftCursor int32
	Fu          struct {
		FpOrInfo  [0]uintptr
		FpAndInfo [0]uintptr
		Fx        struct {
			FleftColumn int32
			FiField     int32
		}
	}
	FprereqRight TBitmask
	FprereqAll   TBitmask
}

** The query generator uses an array of instances of this structure to ** help it analyze the subexpressions of the WHERE clause. Each WHERE ** clause subexpression is separated from the others by AND operators, ** usually, or sometimes subexpressions separated by OR. ** ** All WhereTerms are collected into a single WhereClause structure. ** The following identity holds: ** ** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm ** ** When a term is of the form: ** ** X <op> <expr> ** ** where X is a column name and <op> is one of certain operators, ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the ** cursor number and column number for X. WhereTerm.eOperator records ** the <op> using a bitmask encoding defined by WO_xxx below. The ** use of a bitmask encoding for the operator allows us to search ** quickly for terms that match any of several different operators. ** ** A WhereTerm might also be two or more subterms connected by OR: ** ** (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR .... ** ** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR ** and the WhereTerm.u.pOrInfo field points to auxiliary information that ** is collected about the OR clause. ** ** If a term in the WHERE clause does not match either of the two previous ** categories, then eOperator==0. The WhereTerm.pExpr field is still set ** to the original subexpression content and wtFlags is set up appropriately ** but no other fields in the WhereTerm object are meaningful. ** ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers, ** but they do so indirectly. A single WhereMaskSet structure translates ** cursor number into bits and the translated bit is stored in the prereq ** fields. The translation is used in order to maximize the number of ** bits that will fit in a Bitmask. The VDBE cursor numbers might be ** spread out over the non-negative integers. For example, the cursor ** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet ** translates these sparse cursor numbers into consecutive integers ** beginning with 0 in order to make the best possible use of the available ** bits in the Bitmask. So, in the example above, the cursor numbers ** would be mapped into integers 0 through 7. ** ** The number of terms in a join is limited by the number of bits ** in prereqRight and prereqAll. The default is 64 bits, hence SQLite ** is only able to process joins with 64 or fewer tables.

type TWindow

type TWindow = struct {
	FzName          uintptr
	FzBase          uintptr
	FpPartition     uintptr
	FpOrderBy       uintptr
	FeFrmType       Tu8
	FeStart         Tu8
	FeEnd           Tu8
	FbImplicitFrame Tu8
	FeExclude       Tu8
	FpStart         uintptr
	FpEnd           uintptr
	FppThis         uintptr
	FpNextWin       uintptr
	FpFilter        uintptr
	FpWFunc         uintptr
	FiEphCsr        int32
	FregAccum       int32
	FregResult      int32
	FcsrApp         int32
	FregApp         int32
	FregPart        int32
	FpOwner         uintptr
	FnBufferCol     int32
	FiArgCol        int32
	FregOne         int32
	FregStartRowid  int32
	FregEndRowid    int32
	FbExprArgs      Tu8
}

type TWindow1

type TWindow1 = struct {
	FzName          uintptr
	FzBase          uintptr
	FpPartition     uintptr
	FpOrderBy       uintptr
	FeFrmType       Tu8
	FeStart         Tu8
	FeEnd           Tu8
	FbImplicitFrame Tu8
	FeExclude       Tu8
	FpStart         uintptr
	FpEnd           uintptr
	FppThis         uintptr
	FpNextWin       uintptr
	FpFilter        uintptr
	FpWFunc         uintptr
	FiEphCsr        int32
	FregAccum       int32
	FregResult      int32
	FcsrApp         int32
	FregApp         int32
	FregPart        int32
	FpOwner         uintptr
	FnBufferCol     int32
	FiArgCol        int32
	FregOne         int32
	FregStartRowid  int32
	FregEndRowid    int32
	FbExprArgs      Tu8
}

** This object is used in various ways, most (but not all) related to window ** functions. ** ** (1) A single instance of this structure is attached to the ** the Expr.y.pWin field for each window function in an expression tree. ** This object holds the information contained in the OVER clause, ** plus additional fields used during code generation. ** ** (2) All window functions in a single SELECT form a linked-list ** attached to Select.pWin. The Window.pFunc and Window.pExpr ** fields point back to the expression that is the window function. ** ** (3) The terms of the WINDOW clause of a SELECT are instances of this ** object on a linked list attached to Select.pWinDefn. ** ** (4) For an aggregate function with a FILTER clause, an instance ** of this object is stored in Expr.y.pWin with eFrmType set to ** TK_FILTER. In this case the only field used is Window.pFilter. ** ** The uses (1) and (2) are really the same Window object that just happens ** to be accessible in two different ways. Use case (3) are separate objects.

type TWindowCodeArg

type TWindowCodeArg = struct {
	FpParse    uintptr
	FpMWin     uintptr
	FpVdbe     uintptr
	FaddrGosub int32
	FregGosub  int32
	FregArg    int32
	FeDelete   int32
	FregRowid  int32
	Fstart     TWindowCsrAndReg
	Fcurrent   TWindowCsrAndReg
	Fend       TWindowCsrAndReg
}

type TWindowCodeArg1

type TWindowCodeArg1 = struct {
	FpParse    uintptr
	FpMWin     uintptr
	FpVdbe     uintptr
	FaddrGosub int32
	FregGosub  int32
	FregArg    int32
	FeDelete   int32
	FregRowid  int32
	Fstart     TWindowCsrAndReg
	Fcurrent   TWindowCsrAndReg
	Fend       TWindowCsrAndReg
}

** A single instance of this structure is allocated on the stack by ** sqlite3WindowCodeStep() and a pointer to it passed to the various helper ** routines. This is to reduce the number of arguments required by each ** helper function. ** ** regArg: ** Each window function requires an accumulator register (just as an ** ordinary aggregate function does). This variable is set to the first ** in an array of accumulator registers - one for each window function ** in the WindowCodeArg.pMWin list. ** ** eDelete: ** The window functions implementation sometimes caches the input rows ** that it processes in a temporary table. If it is not zero, this ** variable indicates when rows may be removed from the temp table (in ** order to reduce memory requirements - it would always be safe just ** to leave them there). Possible values for eDelete are: ** ** WINDOW_RETURN_ROW: ** An input row can be discarded after it is returned to the caller. ** ** WINDOW_AGGINVERSE: ** An input row can be discarded after the window functions xInverse() ** callbacks have been invoked in it. ** ** WINDOW_AGGSTEP: ** An input row can be discarded after the window functions xStep() ** callbacks have been invoked in it. ** ** start,current,end ** Consider a window-frame similar to the following: ** ** (ORDER BY a, b GROUPS BETWEEN 2 PRECEDING AND 2 FOLLOWING) ** ** The windows functions implementation caches the input rows in a temp ** table, sorted by "a, b" (it actually populates the cache lazily, and ** aggressively removes rows once they are no longer required, but that's ** a mere detail). It keeps three cursors open on the temp table. One ** (current) that points to the next row to return to the query engine ** once its window function values have been calculated. Another (end) ** points to the next row to call the xStep() method of each window function ** on (so that it is 2 groups ahead of current). And a third (start) that ** points to the next row to call the xInverse() method of each window ** function on. ** ** Each cursor (start, current and end) consists of a VDBE cursor ** (WindowCsrAndReg.csr) and an array of registers (starting at ** WindowCodeArg.reg) that always contains a copy of the peer values ** read from the corresponding cursor. ** ** Depending on the window-frame in question, all three cursors may not ** be required. In this case both WindowCodeArg.csr and reg are set to ** 0.

type TWindowCsrAndReg

type TWindowCsrAndReg = struct {
	Fcsr int32
	Freg int32
}

type TWindowCsrAndReg1

type TWindowCsrAndReg1 = struct {
	Fcsr int32
	Freg int32
}

** See comments above struct WindowCodeArg.

type TWindowRewrite

type TWindowRewrite = struct {
	FpWin       uintptr
	FpSrc       uintptr
	FpSub       uintptr
	FpTab       uintptr
	FpSubSelect uintptr
}

C documentation

/*
** Context object passed through sqlite3WalkExprList() to
** selectWindowRewriteExprCb() by selectWindowRewriteEList().
*/

type TWindowRewrite1

type TWindowRewrite1 = struct {
	FpWin       uintptr
	FpSrc       uintptr
	FpSub       uintptr
	FpTab       uintptr
	FpSubSelect uintptr
}

type TWith

type TWith = struct {
	FnCte   int32
	FbView  int32
	FpOuter uintptr
	Fa      [1]TCte
}

type TWith1

type TWith1 = struct {
	FnCte   int32
	FbView  int32
	FpOuter uintptr
	Fa      [1]TCte
}

** An instance of the With object represents a WITH clause containing ** one or more CTEs (common table expressions).

type TYYMINORTYPE

type TYYMINORTYPE = struct {
	Fyy0   [0]TToken
	Fyy14  [0]uintptr
	Fyy59  [0]uintptr
	Fyy67  [0]uintptr
	Fyy122 [0]uintptr
	Fyy132 [0]uintptr
	Fyy144 [0]int32
	Fyy168 [0]uintptr
	Fyy203 [0]uintptr
	Fyy211 [0]uintptr
	Fyy269 [0]TOnOrUsing
	Fyy286 [0]TTrigEvent
	Fyy383 [0]struct {
		Fvalue int32
		Fmask  int32
	}
	Fyy391        [0]Tu32
	Fyy427        [0]uintptr
	Fyy454        [0]uintptr
	Fyy462        [0]Tu8
	Fyy509        [0]TFrameBound
	Fyy555        [0]uintptr
	Fyyinit       int32
	F__ccgo_pad20 [12]byte
}

C documentation

/* The next sections is a series of control #defines.
** various aspects of the generated parser.
**    YYCODETYPE         is the data type used to store the integer codes
**                       that represent terminal and non-terminal symbols.
**                       "unsigned char" is used if there are fewer than
**                       256 symbols.  Larger types otherwise.
**    YYNOCODE           is a number of type YYCODETYPE that is not used for
**                       any terminal or nonterminal symbol.
**    YYFALLBACK         If defined, this indicates that one or more tokens
**                       (also known as: "terminal symbols") have fall-back
**                       values which should be used if the original symbol
**                       would not parse.  This permits keywords to sometimes
**                       be used as identifiers, for example.
**    YYACTIONTYPE       is the data type used for "action codes" - numbers
**                       that indicate what to do in response to the next
**                       token.
**    sqlite3ParserTOKENTYPE     is the data type used for minor type for terminal
**                       symbols.  Background: A "minor type" is a semantic
**                       value associated with a terminal or non-terminal
**                       symbols.  For example, for an "ID" terminal symbol,
**                       the minor type might be the name of the identifier.
**                       Each non-terminal can have a different minor type.
**                       Terminal symbols all have the same minor type, though.
**                       This macros defines the minor type for terminal
**                       symbols.
**    YYMINORTYPE        is the data type used for all minor types.
**                       This is typically a union of many types, one of
**                       which is sqlite3ParserTOKENTYPE.  The entry in the union
**                       for terminal symbols is called "yy0".
**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
**                       zero the stack is dynamically sized using realloc()
**    sqlite3ParserARG_SDECL     A static variable declaration for the %extra_argument
**    sqlite3ParserARG_PDECL     A parameter declaration for the %extra_argument
**    sqlite3ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
**    sqlite3ParserARG_STORE     Code to store %extra_argument into yypParser
**    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
**    sqlite3ParserCTX_*         As sqlite3ParserARG_ except for %extra_context
**    YYREALLOC          Name of the realloc() function to use
**    YYFREE             Name of the free() function to use
**    YYDYNSTACK         True if stack space should be extended on heap
**    YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
**    YYNSTATE           the combined number of states.
**    YYNRULE            the number of rules in the grammar
**    YYNTOKEN           Number of terminal symbols
**    YY_MAX_SHIFT       Maximum value for shift actions
**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
**    YY_ERROR_ACTION    The yy_action[] code for syntax error
**    YY_ACCEPT_ACTION   The yy_action[] code for accept
**    YY_NO_ACTION       The yy_action[] code for no-op
**    YY_MIN_REDUCE      Minimum value for reduce actions
**    YY_MAX_REDUCE      Maximum value for reduce actions
**    YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
**    YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
*/
/************* Begin control #defines *****************************************/

type T_G_fpos64_t

type T_G_fpos64_t = Tfpos_t

type T_IO_cookie_io_functions_t

type T_IO_cookie_io_functions_t = Tcookie_io_functions_t

type T_ht

type T_ht = struct {
	Fcount uint32
	Fchain uintptr
}

type TabResult

type TabResult = TTabResult

type Table

type Table = TTable

type Table1

type Table1 = TTable1

type TableLock

type TableLock = TTableLock

type TableLock1

type TableLock1 = TTableLock1

type TanalysisInfo

type TanalysisInfo = struct {
	Fdb        uintptr
	FzDatabase uintptr
}

C documentation

/*
** Used to pass information from the analyzer reader through to the
** callback routine.
*/

type TanalysisInfo1

type TanalysisInfo1 = struct {
	Fdb        uintptr
	FzDatabase uintptr
}

type Tbft

type Tbft = uint32

C documentation

/* A bitfield type for use inside of structures.  Always follow with :N where
** N is the number of bits.
*/

type Tblkcnt_t

type Tblkcnt_t = int64

type Tblksize_t

type Tblksize_t = int64

type Tcaddr_t

type Tcaddr_t = uintptr

type Tclock_t

type Tclock_t = int64

type Tclockid_t

type Tclockid_t = int32

type TcompareInfo

type TcompareInfo = struct {
	FmatchAll Tu8
	FmatchOne Tu8
	FmatchSet Tu8
	FnoCase   Tu8
}

** A structure defining how to do GLOB-style comparisons.

type Tcookie_io_functions_t

type Tcookie_io_functions_t = struct {
	Fread   uintptr
	Fwrite  uintptr
	Fseek   uintptr
	Fclose1 uintptr
}

type Tcpu_set_t

type Tcpu_set_t = struct {
	F__bits [16]uint64
}

type Tcpu_set_t1

type Tcpu_set_t1 = struct {
	F__bits [16]uint64
}

type Tdev_t

type Tdev_t = uint64

type Tdiv_t

type Tdiv_t = struct {
	Fquot int32
	Frem  int32
}

type Tdouble_t

type Tdouble_t = float64

type TetByte

type TetByte = uint8

C documentation

/*
** An "etByte" is an 8-bit unsigned value.
*/

type Tet_info

type Tet_info = struct {
	Ffmttype int8
	Fbase    TetByte
	Fflags   TetByte
	Ftype1   TetByte
	Fcharset TetByte
	Fprefix  TetByte
}

C documentation

/*
** Each builtin conversion character (ex: the 'd' in "%d") is described
** by an instance of the following structure
*/

type Tf_owner_ex

type Tf_owner_ex = struct {
	Ftype1 int32
	Fpid   Tpid_t
}

type Tfd_mask

type Tfd_mask = uint64

type Tfd_set

type Tfd_set = struct {
	Ffds_bits [16]uint64
}

type Tfile_handle

type Tfile_handle = struct {
	Fhandle_bytes uint32
	Fhandle_type  int32
}

type Tfinder_type

type Tfinder_type = uintptr

C documentation

/*
** An abstract type for a pointer to an IO method finder function:
*/

type Tfloat_t

type Tfloat_t = float32

type Tflock

type Tflock = struct {
	Fl_type   int16
	Fl_whence int16
	Fl_start  Toff_t
	Fl_len    Toff_t
	Fl_pid    Tpid_t
}

type Tfpos_t

type Tfpos_t = struct {
	F__lldata [0]int64
	F__align  [0]float64
	F__opaque [16]int8
}

type Tfsblkcnt_t

type Tfsblkcnt_t = uint64

type Tfsfilcnt_t

type Tfsfilcnt_t = uint64

type Tfts5YYMINORTYPE

type Tfts5YYMINORTYPE = struct {
	Ffts5yy0     [0]TFts5Token
	Ffts5yy4     [0]int32
	Ffts5yy11    [0]uintptr
	Ffts5yy24    [0]uintptr
	Ffts5yy46    [0]uintptr
	Ffts5yy53    [0]uintptr
	Ffts5yyinit  int32
	F__ccgo_pad7 [12]byte
}

C documentation

/* The next sections is a series of control #defines.
** various aspects of the generated parser.
**    fts5YYCODETYPE         is the data type used to store the integer codes
**                       that represent terminal and non-terminal symbols.
**                       "unsigned char" is used if there are fewer than
**                       256 symbols.  Larger types otherwise.
**    fts5YYNOCODE           is a number of type fts5YYCODETYPE that is not used for
**                       any terminal or nonterminal symbol.
**    fts5YYFALLBACK         If defined, this indicates that one or more tokens
**                       (also known as: "terminal symbols") have fall-back
**                       values which should be used if the original symbol
**                       would not parse.  This permits keywords to sometimes
**                       be used as identifiers, for example.
**    fts5YYACTIONTYPE       is the data type used for "action codes" - numbers
**                       that indicate what to do in response to the next
**                       token.
**    sqlite3Fts5ParserFTS5TOKENTYPE     is the data type used for minor type for terminal
**                       symbols.  Background: A "minor type" is a semantic
**                       value associated with a terminal or non-terminal
**                       symbols.  For example, for an "ID" terminal symbol,
**                       the minor type might be the name of the identifier.
**                       Each non-terminal can have a different minor type.
**                       Terminal symbols all have the same minor type, though.
**                       This macros defines the minor type for terminal
**                       symbols.
**    fts5YYMINORTYPE        is the data type used for all minor types.
**                       This is typically a union of many types, one of
**                       which is sqlite3Fts5ParserFTS5TOKENTYPE.  The entry in the union
**                       for terminal symbols is called "fts5yy0".
**    fts5YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
**                       zero the stack is dynamically sized using realloc()
**    sqlite3Fts5ParserARG_SDECL     A static variable declaration for the %extra_argument
**    sqlite3Fts5ParserARG_PDECL     A parameter declaration for the %extra_argument
**    sqlite3Fts5ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
**    sqlite3Fts5ParserARG_STORE     Code to store %extra_argument into fts5yypParser
**    sqlite3Fts5ParserARG_FETCH     Code to extract %extra_argument from fts5yypParser
**    sqlite3Fts5ParserCTX_*         As sqlite3Fts5ParserARG_ except for %extra_context
**    fts5YYREALLOC          Name of the realloc() function to use
**    fts5YYFREE             Name of the free() function to use
**    fts5YYDYNSTACK         True if stack space should be extended on heap
**    fts5YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
**    fts5YYNSTATE           the combined number of states.
**    fts5YYNRULE            the number of rules in the grammar
**    fts5YYNFTS5TOKEN           Number of terminal symbols
**    fts5YY_MAX_SHIFT       Maximum value for shift actions
**    fts5YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
**    fts5YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
**    fts5YY_ERROR_ACTION    The fts5yy_action[] code for syntax error
**    fts5YY_ACCEPT_ACTION   The fts5yy_action[] code for accept
**    fts5YY_NO_ACTION       The fts5yy_action[] code for no-op
**    fts5YY_MIN_REDUCE      Minimum value for reduce actions
**    fts5YY_MAX_REDUCE      Maximum value for reduce actions
**    fts5YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
**    fts5YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
*/
/************* Begin control #defines *****************************************/

type Tfts5_api

type Tfts5_api = struct {
	FiVersion         int32
	FxCreateTokenizer uintptr
	FxFindTokenizer   uintptr
	FxCreateFunction  uintptr
}

C documentation

/*************************************************************************
** FTS5 EXTENSION REGISTRATION API
*/

type Tfts5_api1

type Tfts5_api1 = struct {
	FiVersion         int32
	FxCreateTokenizer uintptr
	FxFindTokenizer   uintptr
	FxCreateFunction  uintptr
}

type Tfts5_extension_function

type Tfts5_extension_function = uintptr

type Tfts5_tokenizer

type Tfts5_tokenizer = struct {
	FxCreate   uintptr
	FxDelete   uintptr
	FxTokenize uintptr
}

type Tfts5_tokenizer1

type Tfts5_tokenizer1 = struct {
	FxCreate   uintptr
	FxDelete   uintptr
	FxTokenize uintptr
}

type Tfts5yyParser

type Tfts5yyParser = struct {
	Ffts5yytos      uintptr
	FpParse         uintptr
	Ffts5yystackEnd uintptr
	Ffts5yystack    uintptr
	Ffts5yystk0     [100]Tfts5yyStackEntry
}

type Tfts5yyParser1

type Tfts5yyParser1 = struct {
	Ffts5yytos      uintptr
	FpParse         uintptr
	Ffts5yystackEnd uintptr
	Ffts5yystack    uintptr
	Ffts5yystk0     [100]Tfts5yyStackEntry
}

The state of the parser is completely contained in an instance of

** the following structure

type Tfts5yyStackEntry

type Tfts5yyStackEntry = struct {
	Fstateno uint8
	Fmajor   uint8
	Fminor   Tfts5YYMINORTYPE
}

type Tfts5yyStackEntry1

type Tfts5yyStackEntry1 = struct {
	Fstateno uint8
	Fmajor   uint8
	Fminor   Tfts5YYMINORTYPE
}

The following structure represents a single element of the

** parser's stack. Information stored includes: ** ** + The state number for the parser at this level of the stack. ** ** + The value of the token stored at this level of the stack. ** (In other words, the "major" token.) ** ** + The semantic value stored at this level of the stack. This is ** the information used by the action routines in the grammar. ** It is sometimes called the "minor" token. ** ** After the "shift" half of a SHIFTREDUCE action, the stateno field ** actually contains the reduce action for the second half of the ** SHIFTREDUCE.

type Tgid_t

type Tgid_t = uint32

type Tht_slot

type Tht_slot = uint16

C documentation

/*
** Each page of the wal-index mapping contains a hash-table made up of
** an array of HASHTABLE_NSLOT elements of the following type.
*/

type Ti16

type Ti16 = int16

2-byte unsigned integer

type Ti64

type Ti64 = int64

C documentation

/*
** Integers of known sizes.  These typedefs might change for architectures
** where the sizes very.  Preprocessor macros are available so that the
** types can be conveniently redefined at compile-type.  Like this:
**
**         cc '-DUINTPTR_TYPE=long long int' ...
*/

type Ti8

type Ti8 = int8

1-byte unsigned integer

type Tid_t

type Tid_t = uint32

type Tino_t

type Tino_t = uint64

type Tint16_t

type Tint16_t = int16

type Tint32_t

type Tint32_t = int32

type Tint64_t

type Tint64_t = int64

type Tint8_t

type Tint8_t = int8

type Tintptr_t

type Tintptr_t = int64

type Tiovec

type Tiovec = struct {
	Fiov_base uintptr
	Fiov_len  Tsize_t
}

type Titimerspec

type Titimerspec = struct {
	Fit_interval Ttimespec
	Fit_value    Ttimespec
}

type Titimerval

type Titimerval = struct {
	Fit_interval Ttimeval
	Fit_value    Ttimeval
}

type Tkey_t

type Tkey_t = int32

type Tldiv_t

type Tldiv_t = struct {
	Fquot int64
	Frem  int64
}

type Tlldiv_t

type Tlldiv_t = struct {
	Fquot int64
	Frem  int64
}

type Tlocale_t

type Tlocale_t = uintptr

type Tmax_align_t

type Tmax_align_t = struct {
	F__ll int64
	F__ld float64
}

type Tmode_t

type Tmode_t = uint32

type Tnlink_t

type Tnlink_t = uint64

type Toff_t

type Toff_t = int64

type Token

type Token = TToken

type Token1

type Token1 = TToken1

type TokenCtx

type TokenCtx = TTokenCtx

type TokenCtx1

type TokenCtx1 = TTokenCtx1

type Tp4union

type Tp4union = struct {
	Fp            [0]uintptr
	Fz            [0]uintptr
	FpI64         [0]uintptr
	FpReal        [0]uintptr
	FpFunc        [0]uintptr
	FpCtx         [0]uintptr
	FpColl        [0]uintptr
	FpMem         [0]uintptr
	FpVtab        [0]uintptr
	FpKeyInfo     [0]uintptr
	Fai           [0]uintptr
	FpProgram     [0]uintptr
	FpTab         [0]uintptr
	Fi            int32
	F__ccgo_pad14 [4]byte
}

type Tpid_t

type Tpid_t = int32

type Tpthread_attr_t

type Tpthread_attr_t = struct {
	F__u struct {
		F__vi [0][14]int32
		F__s  [0][7]uint64
		F__i  [14]int32
	}
}

type Tpthread_barrier_t

type Tpthread_barrier_t = struct {
	F__u struct {
		F__vi [0][8]int32
		F__p  [0][4]uintptr
		F__i  [8]int32
	}
}

type Tpthread_barrierattr_t

type Tpthread_barrierattr_t = struct {
	F__attr uint32
}

type Tpthread_cond_t

type Tpthread_cond_t = struct {
	F__u struct {
		F__vi [0][12]int32
		F__p  [0][6]uintptr
		F__i  [12]int32
	}
}

type Tpthread_condattr_t

type Tpthread_condattr_t = struct {
	F__attr uint32
}

type Tpthread_key_t

type Tpthread_key_t = uint32

type Tpthread_mutex_t

type Tpthread_mutex_t = struct {
	F__u struct {
		F__vi [0][10]int32
		F__p  [0][5]uintptr
		F__i  [10]int32
	}
}

type Tpthread_mutexattr_t

type Tpthread_mutexattr_t = struct {
	F__attr uint32
}

type Tpthread_once_t

type Tpthread_once_t = int32

type Tpthread_rwlock_t

type Tpthread_rwlock_t = struct {
	F__u struct {
		F__vi [0][14]int32
		F__p  [0][7]uintptr
		F__i  [14]int32
	}
}

type Tpthread_rwlockattr_t

type Tpthread_rwlockattr_t = struct {
	F__attr [2]uint32
}

type Tpthread_spinlock_t

type Tpthread_spinlock_t = int32

type Tpthread_t

type Tpthread_t = uintptr

type Tptrdiff_t

type Tptrdiff_t = int64

type Tquad_t

type Tquad_t = int64

type Trbu_file

type Trbu_file = struct {
	Fbase         Tsqlite3_file
	FpReal        uintptr
	FpRbuVfs      uintptr
	FpRbu         uintptr
	Fsz           Ti64
	FopenFlags    int32
	FiCookie      Tu32
	FiWriteVer    Tu8
	FbNolock      Tu8
	FnShm         int32
	FapShm        uintptr
	FzDel         uintptr
	FzWal         uintptr
	FpWalFd       uintptr
	FpMainNext    uintptr
	FpMainRbuNext uintptr
}

type Trbu_file1

type Trbu_file1 = struct {
	Fbase         Tsqlite3_file
	FpReal        uintptr
	FpRbuVfs      uintptr
	FpRbu         uintptr
	Fsz           Ti64
	FopenFlags    int32
	FiCookie      Tu32
	FiWriteVer    Tu8
	FbNolock      Tu8
	FnShm         int32
	FapShm        uintptr
	FzDel         uintptr
	FzWal         uintptr
	FpWalFd       uintptr
	FpMainNext    uintptr
	FpMainRbuNext uintptr
}

** Each file opened by an rbu VFS is represented by an instance of ** the following structure. ** ** If this is a temporary file (pRbu!=0 && flags&DELETE_ON_CLOSE), variable ** "sz" is set to the current size of the database file.

type Trbu_vfs

type Trbu_vfs = struct {
	Fbase     Tsqlite3_vfs
	FpRealVfs uintptr
	Fmutex    uintptr
	FpRbu     uintptr
	FpMain    uintptr
	FpMainRbu uintptr
}

type Trbu_vfs1

type Trbu_vfs1 = struct {
	Fbase     Tsqlite3_vfs
	FpRealVfs uintptr
	Fmutex    uintptr
	FpRbu     uintptr
	FpMain    uintptr
	FpMainRbu uintptr
}

** An rbu VFS is implemented using an instance of this structure. ** ** Variable pRbu is only non-NULL for automatically created RBU VFS objects. ** It is NULL for RBU VFS objects created explicitly using ** sqlite3rbu_create_vfs(). It is used to track the total amount of temp ** space used by the RBU handle.

type Tregister_t

type Tregister_t = int64

type TrigEvent

type TrigEvent = TTrigEvent

type Trigger

type Trigger = TTrigger

type Trigger1

type Trigger1 = TTrigger1

type TriggerPrg

type TriggerPrg = TTriggerPrg

type TriggerPrg1

type TriggerPrg1 = TTriggerPrg1

type TriggerStep

type TriggerStep = TTriggerStep

type TriggerStep1

type TriggerStep1 = TTriggerStep1

type TrigramTokenizer

type TrigramTokenizer = TTrigramTokenizer

type TrigramTokenizer1

type TrigramTokenizer1 = TTrigramTokenizer1

type TsColMap

type TsColMap = struct {
	FiFrom int32
	FzCol  uintptr
}

type Tsched_param

type Tsched_param = struct {
	Fsched_priority int32
	F__reserved1    int32
	F__reserved2    [2]struct {
		F__reserved1 Ttime_t
		F__reserved2 int64
	}
	F__reserved3 int32
}

type Tsigset_t

type Tsigset_t = struct {
	F__bits [16]uint64
}

type Tsize_t

type Tsize_t = uint64

type Tsqlite3

type Tsqlite3 = struct {
	FpVfs                   uintptr
	FpVdbe                  uintptr
	FpDfltColl              uintptr
	Fmutex                  uintptr
	FaDb                    uintptr
	FnDb                    int32
	FmDbFlags               Tu32
	Fflags                  Tu64
	FlastRowid              Ti64
	FszMmap                 Ti64
	FnSchemaLock            Tu32
	FopenFlags              uint32
	FerrCode                int32
	FerrByteOffset          int32
	FerrMask                int32
	FiSysErrno              int32
	FdbOptFlags             Tu32
	Fenc                    Tu8
	FautoCommit             Tu8
	Ftemp_store             Tu8
	FmallocFailed           Tu8
	FbBenignMalloc          Tu8
	FdfltLockMode           Tu8
	FnextAutovac            int8
	FsuppressErr            Tu8
	FvtabOnConflict         Tu8
	FisTransactionSavepoint Tu8
	FmTrace                 Tu8
	FnoSharedCache          Tu8
	FnSqlExec               Tu8
	FeOpenState             Tu8
	FnextPagesize           int32
	FnChange                Ti64
	FnTotalChange           Ti64
	FaLimit                 [12]int32
	FnMaxSorterMmap         int32
	Finit1                  Tsqlite3InitInfo
	FnVdbeActive            int32
	FnVdbeRead              int32
	FnVdbeWrite             int32
	FnVdbeExec              int32
	FnVDestroy              int32
	FnExtension             int32
	FaExtension             uintptr
	Ftrace                  struct {
		FxV2     [0]uintptr
		FxLegacy uintptr
	}
	FpTraceArg          uintptr
	FxProfile           uintptr
	FpProfileArg        uintptr
	FpCommitArg         uintptr
	FxCommitCallback    uintptr
	FpRollbackArg       uintptr
	FxRollbackCallback  uintptr
	FpUpdateArg         uintptr
	FxUpdateCallback    uintptr
	FpAutovacPagesArg   uintptr
	FxAutovacDestr      uintptr
	FxAutovacPages      uintptr
	FpParse             uintptr
	FpPreUpdateArg      uintptr
	FxPreUpdateCallback uintptr
	FpPreUpdate         uintptr
	FxWalCallback       uintptr
	FpWalArg            uintptr
	FxCollNeeded        uintptr
	FxCollNeeded16      uintptr
	FpCollNeededArg     uintptr
	FpErr               uintptr
	Fu1                 struct {
		FnotUsed1      [0]float64
		FisInterrupted int32
		F__ccgo_pad2   [4]byte
	}
	Flookaside           TLookaside
	FxAuth               Tsqlite3_xauth
	FpAuthArg            uintptr
	FxProgress           uintptr
	FpProgressArg        uintptr
	FnProgressOps        uint32
	FnVTrans             int32
	FaModule             THash
	FpVtabCtx            uintptr
	FaVTrans             uintptr
	FpDisconnect         uintptr
	FaFunc               THash
	FaCollSeq            THash
	FbusyHandler         TBusyHandler
	FaDbStatic           [2]TDb
	FpSavepoint          uintptr
	FnAnalysisLimit      int32
	FbusyTimeout         int32
	FnSavepoint          int32
	FnStatement          int32
	FnDeferredCons       Ti64
	FnDeferredImmCons    Ti64
	FpnBytesFreed        uintptr
	FpDbData             uintptr
	FpBlockingConnection uintptr
	FpUnlockConnection   uintptr
	FpUnlockArg          uintptr
	FxUnlockNotify       uintptr
	FpNextBlocked        uintptr
}

C documentation

/*
** CAPI3REF: Database Connection Handle
** KEYWORDS: {database connection} {database connections}
**
** Each open SQLite database is represented by a pointer to an instance of
** the opaque structure named "sqlite3".  It is useful to think of an sqlite3
** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and
** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
** and [sqlite3_close_v2()] are its destructors.  There are many other
** interfaces (such as
** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
** [sqlite3_busy_timeout()] to name but three) that are methods on an
** sqlite3 object.
*/

type Tsqlite31

type Tsqlite31 = struct {
	FpVfs                   uintptr
	FpVdbe                  uintptr
	FpDfltColl              uintptr
	Fmutex                  uintptr
	FaDb                    uintptr
	FnDb                    int32
	FmDbFlags               Tu32
	Fflags                  Tu64
	FlastRowid              Ti64
	FszMmap                 Ti64
	FnSchemaLock            Tu32
	FopenFlags              uint32
	FerrCode                int32
	FerrByteOffset          int32
	FerrMask                int32
	FiSysErrno              int32
	FdbOptFlags             Tu32
	Fenc                    Tu8
	FautoCommit             Tu8
	Ftemp_store             Tu8
	FmallocFailed           Tu8
	FbBenignMalloc          Tu8
	FdfltLockMode           Tu8
	FnextAutovac            int8
	FsuppressErr            Tu8
	FvtabOnConflict         Tu8
	FisTransactionSavepoint Tu8
	FmTrace                 Tu8
	FnoSharedCache          Tu8
	FnSqlExec               Tu8
	FeOpenState             Tu8
	FnextPagesize           int32
	FnChange                Ti64
	FnTotalChange           Ti64
	FaLimit                 [12]int32
	FnMaxSorterMmap         int32
	Finit1                  Tsqlite3InitInfo
	FnVdbeActive            int32
	FnVdbeRead              int32
	FnVdbeWrite             int32
	FnVdbeExec              int32
	FnVDestroy              int32
	FnExtension             int32
	FaExtension             uintptr
	Ftrace                  struct {
		FxV2     [0]uintptr
		FxLegacy uintptr
	}
	FpTraceArg          uintptr
	FxProfile           uintptr
	FpProfileArg        uintptr
	FpCommitArg         uintptr
	FxCommitCallback    uintptr
	FpRollbackArg       uintptr
	FxRollbackCallback  uintptr
	FpUpdateArg         uintptr
	FxUpdateCallback    uintptr
	FpAutovacPagesArg   uintptr
	FxAutovacDestr      uintptr
	FxAutovacPages      uintptr
	FpParse             uintptr
	FpPreUpdateArg      uintptr
	FxPreUpdateCallback uintptr
	FpPreUpdate         uintptr
	FxWalCallback       uintptr
	FpWalArg            uintptr
	FxCollNeeded        uintptr
	FxCollNeeded16      uintptr
	FpCollNeededArg     uintptr
	FpErr               uintptr
	Fu1                 struct {
		FnotUsed1      [0]float64
		FisInterrupted int32
		F__ccgo_pad2   [4]byte
	}
	Flookaside           TLookaside
	FxAuth               Tsqlite3_xauth
	FpAuthArg            uintptr
	FxProgress           uintptr
	FpProgressArg        uintptr
	FnProgressOps        uint32
	FnVTrans             int32
	FaModule             THash
	FpVtabCtx            uintptr
	FaVTrans             uintptr
	FpDisconnect         uintptr
	FaFunc               THash
	FaCollSeq            THash
	FbusyHandler         TBusyHandler
	FaDbStatic           [2]TDb
	FpSavepoint          uintptr
	FnAnalysisLimit      int32
	FbusyTimeout         int32
	FnSavepoint          int32
	FnStatement          int32
	FnDeferredCons       Ti64
	FnDeferredImmCons    Ti64
	FpnBytesFreed        uintptr
	FpDbData             uintptr
	FpBlockingConnection uintptr
	FpUnlockConnection   uintptr
	FpUnlockArg          uintptr
	FxUnlockNotify       uintptr
	FpNextBlocked        uintptr
}

** Each database connection is an instance of the following structure.

type Tsqlite3AutoExtList

type Tsqlite3AutoExtList = struct {
	FnExt Tu32
	FaExt uintptr
}

C documentation

/*
** The following object holds the list of automatically loaded
** extensions.
**
** This list is shared across threads.  The SQLITE_MUTEX_STATIC_MAIN
** mutex must be held while accessing this list.
*/

type Tsqlite3AutoExtList1

type Tsqlite3AutoExtList1 = struct {
	FnExt Tu32
	FaExt uintptr
}

type Tsqlite3InitInfo

type Tsqlite3InitInfo = struct {
	FnewTnum       TPgno
	FiDb           Tu8
	Fbusy          Tu8
	F__ccgo_align3 [2]byte
	F__ccgo8       uint8
	FazInit        uintptr
}

type Tsqlite3PrngType

type Tsqlite3PrngType = struct {
	Fs   [16]Tu32
	Fout [64]Tu8
	Fn   Tu8
}

C documentation

/* All threads share a single random number generator.
** This structure is the current state of the generator.
*/

type Tsqlite3StatType

type Tsqlite3StatType = struct {
	FnowValue [10]Tsqlite3StatValueType
	FmxValue  [10]Tsqlite3StatValueType
}

type Tsqlite3StatType1

type Tsqlite3StatType1 = struct {
	FnowValue [10]Tsqlite3StatValueType
	FmxValue  [10]Tsqlite3StatValueType
}

type Tsqlite3StatValueType

type Tsqlite3StatValueType = int64

C documentation

/*
** Variables in which to record status information.
*/

type Tsqlite3_api_routines

type Tsqlite3_api_routines = struct {
	Faggregate_context      uintptr
	Faggregate_count        uintptr
	Fbind_blob              uintptr
	Fbind_double            uintptr
	Fbind_int               uintptr
	Fbind_int64             uintptr
	Fbind_null              uintptr
	Fbind_parameter_count   uintptr
	Fbind_parameter_index   uintptr
	Fbind_parameter_name    uintptr
	Fbind_text              uintptr
	Fbind_text16            uintptr
	Fbind_value             uintptr
	Fbusy_handler           uintptr
	Fbusy_timeout           uintptr
	Fchanges                uintptr
	Fclose1                 uintptr
	Fcollation_needed       uintptr
	Fcollation_needed16     uintptr
	Fcolumn_blob            uintptr
	Fcolumn_bytes           uintptr
	Fcolumn_bytes16         uintptr
	Fcolumn_count           uintptr
	Fcolumn_database_name   uintptr
	Fcolumn_database_name16 uintptr
	Fcolumn_decltype        uintptr
	Fcolumn_decltype16      uintptr
	Fcolumn_double          uintptr
	Fcolumn_int             uintptr
	Fcolumn_int64           uintptr
	Fcolumn_name            uintptr
	Fcolumn_name16          uintptr
	Fcolumn_origin_name     uintptr
	Fcolumn_origin_name16   uintptr
	Fcolumn_table_name      uintptr
	Fcolumn_table_name16    uintptr
	Fcolumn_text            uintptr
	Fcolumn_text16          uintptr
	Fcolumn_type            uintptr
	Fcolumn_value           uintptr
	Fcommit_hook            uintptr
	Fcomplete               uintptr
	Fcomplete16             uintptr
	Fcreate_collation       uintptr
	Fcreate_collation16     uintptr
	Fcreate_function        uintptr
	Fcreate_function16      uintptr
	Fcreate_module          uintptr
	Fdata_count             uintptr
	Fdb_handle              uintptr
	Fdeclare_vtab           uintptr
	Fenable_shared_cache    uintptr
	Ferrcode                uintptr
	Ferrmsg                 uintptr
	Ferrmsg16               uintptr
	Fexec                   uintptr
	Fexpired                uintptr
	Ffinalize               uintptr
	Ffree                   uintptr
	Ffree_table             uintptr
	Fget_autocommit         uintptr
	Fget_auxdata            uintptr
	Fget_table              uintptr
	Fglobal_recover         uintptr
	Finterruptx             uintptr
	Flast_insert_rowid      uintptr
	Flibversion             uintptr
	Flibversion_number      uintptr
	Fmalloc                 uintptr
	Fmprintf                uintptr
	Fopen                   uintptr
	Fopen16                 uintptr
	Fprepare                uintptr
	Fprepare16              uintptr
	Fprofile                uintptr
	Fprogress_handler       uintptr
	Frealloc                uintptr
	Freset                  uintptr
	Fresult_blob            uintptr
	Fresult_double          uintptr
	Fresult_error           uintptr
	Fresult_error16         uintptr
	Fresult_int             uintptr
	Fresult_int64           uintptr
	Fresult_null            uintptr
	Fresult_text            uintptr
	Fresult_text16          uintptr
	Fresult_text16be        uintptr
	Fresult_text16le        uintptr
	Fresult_value           uintptr
	Frollback_hook          uintptr
	Fset_authorizer         uintptr
	Fset_auxdata            uintptr
	Fxsnprintf              uintptr
	Fstep                   uintptr
	Ftable_column_metadata  uintptr
	Fthread_cleanup         uintptr
	Ftotal_changes          uintptr
	Ftrace                  uintptr
	Ftransfer_bindings      uintptr
	Fupdate_hook            uintptr
	Fuser_data              uintptr
	Fvalue_blob             uintptr
	Fvalue_bytes            uintptr
	Fvalue_bytes16          uintptr
	Fvalue_double           uintptr
	Fvalue_int              uintptr
	Fvalue_int64            uintptr
	Fvalue_numeric_type     uintptr
	Fvalue_text             uintptr
	Fvalue_text16           uintptr
	Fvalue_text16be         uintptr
	Fvalue_text16le         uintptr
	Fvalue_type             uintptr
	Fvmprintf               uintptr
	Foverload_function      uintptr
	Fprepare_v2             uintptr
	Fprepare16_v2           uintptr
	Fclear_bindings         uintptr
	Fcreate_module_v2       uintptr
	Fbind_zeroblob          uintptr
	Fblob_bytes             uintptr
	Fblob_close             uintptr
	Fblob_open              uintptr
	Fblob_read              uintptr
	Fblob_write             uintptr
	Fcreate_collation_v2    uintptr
	Ffile_control           uintptr
	Fmemory_highwater       uintptr
	Fmemory_used            uintptr
	Fmutex_alloc            uintptr
	Fmutex_enter            uintptr
	Fmutex_free             uintptr
	Fmutex_leave            uintptr
	Fmutex_try              uintptr
	Fopen_v2                uintptr
	Frelease_memory         uintptr
	Fresult_error_nomem     uintptr
	Fresult_error_toobig    uintptr
	Fsleep                  uintptr
	Fsoft_heap_limit        uintptr
	Fvfs_find               uintptr
	Fvfs_register           uintptr
	Fvfs_unregister         uintptr
	Fxthreadsafe            uintptr
	Fresult_zeroblob        uintptr
	Fresult_error_code      uintptr
	Ftest_control           uintptr
	Frandomness             uintptr
	Fcontext_db_handle      uintptr
	Fextended_result_codes  uintptr
	Flimit                  uintptr
	Fnext_stmt              uintptr
	Fsql                    uintptr
	Fstatus                 uintptr
	Fbackup_finish          uintptr
	Fbackup_init            uintptr
	Fbackup_pagecount       uintptr
	Fbackup_remaining       uintptr
	Fbackup_step            uintptr
	Fcompileoption_get      uintptr
	Fcompileoption_used     uintptr
	Fcreate_function_v2     uintptr
	Fdb_config              uintptr
	Fdb_mutex               uintptr
	Fdb_status              uintptr
	Fextended_errcode       uintptr
	Flog                    uintptr
	Fsoft_heap_limit64      uintptr
	Fsourceid               uintptr
	Fstmt_status            uintptr
	Fstrnicmp               uintptr
	Funlock_notify          uintptr
	Fwal_autocheckpoint     uintptr
	Fwal_checkpoint         uintptr
	Fwal_hook               uintptr
	Fblob_reopen            uintptr
	Fvtab_config            uintptr
	Fvtab_on_conflict       uintptr
	Fclose_v2               uintptr
	Fdb_filename            uintptr
	Fdb_readonly            uintptr
	Fdb_release_memory      uintptr
	Ferrstr                 uintptr
	Fstmt_busy              uintptr
	Fstmt_readonly          uintptr
	Fstricmp                uintptr
	Furi_boolean            uintptr
	Furi_int64              uintptr
	Furi_parameter          uintptr
	Fxvsnprintf             uintptr
	Fwal_checkpoint_v2      uintptr
	Fauto_extension         uintptr
	Fbind_blob64            uintptr
	Fbind_text64            uintptr
	Fcancel_auto_extension  uintptr
	Fload_extension         uintptr
	Fmalloc64               uintptr
	Fmsize                  uintptr
	Frealloc64              uintptr
	Freset_auto_extension   uintptr
	Fresult_blob64          uintptr
	Fresult_text64          uintptr
	Fstrglob                uintptr
	Fvalue_dup              uintptr
	Fvalue_free             uintptr
	Fresult_zeroblob64      uintptr
	Fbind_zeroblob64        uintptr
	Fvalue_subtype          uintptr
	Fresult_subtype         uintptr
	Fstatus64               uintptr
	Fstrlike                uintptr
	Fdb_cacheflush          uintptr
	Fsystem_errno           uintptr
	Ftrace_v2               uintptr
	Fexpanded_sql           uintptr
	Fset_last_insert_rowid  uintptr
	Fprepare_v3             uintptr
	Fprepare16_v3           uintptr
	Fbind_pointer           uintptr
	Fresult_pointer         uintptr
	Fvalue_pointer          uintptr
	Fvtab_nochange          uintptr
	Fvalue_nochange         uintptr
	Fvtab_collation         uintptr
	Fkeyword_count          uintptr
	Fkeyword_name           uintptr
	Fkeyword_check          uintptr
	Fstr_new                uintptr
	Fstr_finish             uintptr
	Fstr_appendf            uintptr
	Fstr_vappendf           uintptr
	Fstr_append             uintptr
	Fstr_appendall          uintptr
	Fstr_appendchar         uintptr
	Fstr_reset              uintptr
	Fstr_errcode            uintptr
	Fstr_length             uintptr
	Fstr_value              uintptr
	Fcreate_window_function uintptr
	Fnormalized_sql         uintptr
	Fstmt_isexplain         uintptr
	Fvalue_frombind         uintptr
	Fdrop_modules           uintptr
	Fhard_heap_limit64      uintptr
	Furi_key                uintptr
	Ffilename_database      uintptr
	Ffilename_journal       uintptr
	Ffilename_wal           uintptr
	Fcreate_filename        uintptr
	Ffree_filename          uintptr
	Fdatabase_file_object   uintptr
	Ftxn_state              uintptr
	Fchanges64              uintptr
	Ftotal_changes64        uintptr
	Fautovacuum_pages       uintptr
	Ferror_offset           uintptr
	Fvtab_rhs_value         uintptr
	Fvtab_distinct          uintptr
	Fvtab_in                uintptr
	Fvtab_in_first          uintptr
	Fvtab_in_next           uintptr
	Fdeserialize            uintptr
	Fserialize              uintptr
	Fdb_name                uintptr
	Fvalue_encoding         uintptr
	Fis_interrupted         uintptr
	Fstmt_explain           uintptr
	Fget_clientdata         uintptr
	Fset_clientdata         uintptr
}

C documentation

/*
** CAPI3REF: Loadable Extension Thunk
**
** A pointer to the opaque sqlite3_api_routines structure is passed as
** the third parameter to entry points of [loadable extensions].  This
** structure must be typedefed in order to work around compiler warnings
** on some platforms.
*/

type Tsqlite3_api_routines1

type Tsqlite3_api_routines1 = struct {
	Faggregate_context      uintptr
	Faggregate_count        uintptr
	Fbind_blob              uintptr
	Fbind_double            uintptr
	Fbind_int               uintptr
	Fbind_int64             uintptr
	Fbind_null              uintptr
	Fbind_parameter_count   uintptr
	Fbind_parameter_index   uintptr
	Fbind_parameter_name    uintptr
	Fbind_text              uintptr
	Fbind_text16            uintptr
	Fbind_value             uintptr
	Fbusy_handler           uintptr
	Fbusy_timeout           uintptr
	Fchanges                uintptr
	Fclose1                 uintptr
	Fcollation_needed       uintptr
	Fcollation_needed16     uintptr
	Fcolumn_blob            uintptr
	Fcolumn_bytes           uintptr
	Fcolumn_bytes16         uintptr
	Fcolumn_count           uintptr
	Fcolumn_database_name   uintptr
	Fcolumn_database_name16 uintptr
	Fcolumn_decltype        uintptr
	Fcolumn_decltype16      uintptr
	Fcolumn_double          uintptr
	Fcolumn_int             uintptr
	Fcolumn_int64           uintptr
	Fcolumn_name            uintptr
	Fcolumn_name16          uintptr
	Fcolumn_origin_name     uintptr
	Fcolumn_origin_name16   uintptr
	Fcolumn_table_name      uintptr
	Fcolumn_table_name16    uintptr
	Fcolumn_text            uintptr
	Fcolumn_text16          uintptr
	Fcolumn_type            uintptr
	Fcolumn_value           uintptr
	Fcommit_hook            uintptr
	Fcomplete               uintptr
	Fcomplete16             uintptr
	Fcreate_collation       uintptr
	Fcreate_collation16     uintptr
	Fcreate_function        uintptr
	Fcreate_function16      uintptr
	Fcreate_module          uintptr
	Fdata_count             uintptr
	Fdb_handle              uintptr
	Fdeclare_vtab           uintptr
	Fenable_shared_cache    uintptr
	Ferrcode                uintptr
	Ferrmsg                 uintptr
	Ferrmsg16               uintptr
	Fexec                   uintptr
	Fexpired                uintptr
	Ffinalize               uintptr
	Ffree                   uintptr
	Ffree_table             uintptr
	Fget_autocommit         uintptr
	Fget_auxdata            uintptr
	Fget_table              uintptr
	Fglobal_recover         uintptr
	Finterruptx             uintptr
	Flast_insert_rowid      uintptr
	Flibversion             uintptr
	Flibversion_number      uintptr
	Fmalloc                 uintptr
	Fmprintf                uintptr
	Fopen                   uintptr
	Fopen16                 uintptr
	Fprepare                uintptr
	Fprepare16              uintptr
	Fprofile                uintptr
	Fprogress_handler       uintptr
	Frealloc                uintptr
	Freset                  uintptr
	Fresult_blob            uintptr
	Fresult_double          uintptr
	Fresult_error           uintptr
	Fresult_error16         uintptr
	Fresult_int             uintptr
	Fresult_int64           uintptr
	Fresult_null            uintptr
	Fresult_text            uintptr
	Fresult_text16          uintptr
	Fresult_text16be        uintptr
	Fresult_text16le        uintptr
	Fresult_value           uintptr
	Frollback_hook          uintptr
	Fset_authorizer         uintptr
	Fset_auxdata            uintptr
	Fxsnprintf              uintptr
	Fstep                   uintptr
	Ftable_column_metadata  uintptr
	Fthread_cleanup         uintptr
	Ftotal_changes          uintptr
	Ftrace                  uintptr
	Ftransfer_bindings      uintptr
	Fupdate_hook            uintptr
	Fuser_data              uintptr
	Fvalue_blob             uintptr
	Fvalue_bytes            uintptr
	Fvalue_bytes16          uintptr
	Fvalue_double           uintptr
	Fvalue_int              uintptr
	Fvalue_int64            uintptr
	Fvalue_numeric_type     uintptr
	Fvalue_text             uintptr
	Fvalue_text16           uintptr
	Fvalue_text16be         uintptr
	Fvalue_text16le         uintptr
	Fvalue_type             uintptr
	Fvmprintf               uintptr
	Foverload_function      uintptr
	Fprepare_v2             uintptr
	Fprepare16_v2           uintptr
	Fclear_bindings         uintptr
	Fcreate_module_v2       uintptr
	Fbind_zeroblob          uintptr
	Fblob_bytes             uintptr
	Fblob_close             uintptr
	Fblob_open              uintptr
	Fblob_read              uintptr
	Fblob_write             uintptr
	Fcreate_collation_v2    uintptr
	Ffile_control           uintptr
	Fmemory_highwater       uintptr
	Fmemory_used            uintptr
	Fmutex_alloc            uintptr
	Fmutex_enter            uintptr
	Fmutex_free             uintptr
	Fmutex_leave            uintptr
	Fmutex_try              uintptr
	Fopen_v2                uintptr
	Frelease_memory         uintptr
	Fresult_error_nomem     uintptr
	Fresult_error_toobig    uintptr
	Fsleep                  uintptr
	Fsoft_heap_limit        uintptr
	Fvfs_find               uintptr
	Fvfs_register           uintptr
	Fvfs_unregister         uintptr
	Fxthreadsafe            uintptr
	Fresult_zeroblob        uintptr
	Fresult_error_code      uintptr
	Ftest_control           uintptr
	Frandomness             uintptr
	Fcontext_db_handle      uintptr
	Fextended_result_codes  uintptr
	Flimit                  uintptr
	Fnext_stmt              uintptr
	Fsql                    uintptr
	Fstatus                 uintptr
	Fbackup_finish          uintptr
	Fbackup_init            uintptr
	Fbackup_pagecount       uintptr
	Fbackup_remaining       uintptr
	Fbackup_step            uintptr
	Fcompileoption_get      uintptr
	Fcompileoption_used     uintptr
	Fcreate_function_v2     uintptr
	Fdb_config              uintptr
	Fdb_mutex               uintptr
	Fdb_status              uintptr
	Fextended_errcode       uintptr
	Flog                    uintptr
	Fsoft_heap_limit64      uintptr
	Fsourceid               uintptr
	Fstmt_status            uintptr
	Fstrnicmp               uintptr
	Funlock_notify          uintptr
	Fwal_autocheckpoint     uintptr
	Fwal_checkpoint         uintptr
	Fwal_hook               uintptr
	Fblob_reopen            uintptr
	Fvtab_config            uintptr
	Fvtab_on_conflict       uintptr
	Fclose_v2               uintptr
	Fdb_filename            uintptr
	Fdb_readonly            uintptr
	Fdb_release_memory      uintptr
	Ferrstr                 uintptr
	Fstmt_busy              uintptr
	Fstmt_readonly          uintptr
	Fstricmp                uintptr
	Furi_boolean            uintptr
	Furi_int64              uintptr
	Furi_parameter          uintptr
	Fxvsnprintf             uintptr
	Fwal_checkpoint_v2      uintptr
	Fauto_extension         uintptr
	Fbind_blob64            uintptr
	Fbind_text64            uintptr
	Fcancel_auto_extension  uintptr
	Fload_extension         uintptr
	Fmalloc64               uintptr
	Fmsize                  uintptr
	Frealloc64              uintptr
	Freset_auto_extension   uintptr
	Fresult_blob64          uintptr
	Fresult_text64          uintptr
	Fstrglob                uintptr
	Fvalue_dup              uintptr
	Fvalue_free             uintptr
	Fresult_zeroblob64      uintptr
	Fbind_zeroblob64        uintptr
	Fvalue_subtype          uintptr
	Fresult_subtype         uintptr
	Fstatus64               uintptr
	Fstrlike                uintptr
	Fdb_cacheflush          uintptr
	Fsystem_errno           uintptr
	Ftrace_v2               uintptr
	Fexpanded_sql           uintptr
	Fset_last_insert_rowid  uintptr
	Fprepare_v3             uintptr
	Fprepare16_v3           uintptr
	Fbind_pointer           uintptr
	Fresult_pointer         uintptr
	Fvalue_pointer          uintptr
	Fvtab_nochange          uintptr
	Fvalue_nochange         uintptr
	Fvtab_collation         uintptr
	Fkeyword_count          uintptr
	Fkeyword_name           uintptr
	Fkeyword_check          uintptr
	Fstr_new                uintptr
	Fstr_finish             uintptr
	Fstr_appendf            uintptr
	Fstr_vappendf           uintptr
	Fstr_append             uintptr
	Fstr_appendall          uintptr
	Fstr_appendchar         uintptr
	Fstr_reset              uintptr
	Fstr_errcode            uintptr
	Fstr_length             uintptr
	Fstr_value              uintptr
	Fcreate_window_function uintptr
	Fnormalized_sql         uintptr
	Fstmt_isexplain         uintptr
	Fvalue_frombind         uintptr
	Fdrop_modules           uintptr
	Fhard_heap_limit64      uintptr
	Furi_key                uintptr
	Ffilename_database      uintptr
	Ffilename_journal       uintptr
	Ffilename_wal           uintptr
	Fcreate_filename        uintptr
	Ffree_filename          uintptr
	Fdatabase_file_object   uintptr
	Ftxn_state              uintptr
	Fchanges64              uintptr
	Ftotal_changes64        uintptr
	Fautovacuum_pages       uintptr
	Ferror_offset           uintptr
	Fvtab_rhs_value         uintptr
	Fvtab_distinct          uintptr
	Fvtab_in                uintptr
	Fvtab_in_first          uintptr
	Fvtab_in_next           uintptr
	Fdeserialize            uintptr
	Fserialize              uintptr
	Fdb_name                uintptr
	Fvalue_encoding         uintptr
	Fis_interrupted         uintptr
	Fstmt_explain           uintptr
	Fget_clientdata         uintptr
	Fset_clientdata         uintptr
}

** The following structure holds pointers to all of the SQLite API ** routines. ** ** WARNING: In order to maintain backwards compatibility, add new ** interfaces to the end of this structure only. If you insert new ** interfaces in the middle of this structure, then older different ** versions of SQLite will not be able to load each other's shared ** libraries!

type Tsqlite3_backup

type Tsqlite3_backup = struct {
	FpDestDb     uintptr
	FpDest       uintptr
	FiDestSchema Tu32
	FbDestLocked int32
	FiNext       TPgno
	FpSrcDb      uintptr
	FpSrc        uintptr
	Frc          int32
	FnRemaining  TPgno
	FnPagecount  TPgno
	FisAttached  int32
	FpNext       uintptr
}

C documentation

/*
** CAPI3REF: Online Backup Object
**
** The sqlite3_backup object records state information about an ongoing
** online backup operation.  ^The sqlite3_backup object is created by
** a call to [sqlite3_backup_init()] and is destroyed by a call to
** [sqlite3_backup_finish()].
**
** See Also: [Using the SQLite Online Backup API]
*/

type Tsqlite3_backup1

type Tsqlite3_backup1 = struct {
	FpDestDb     uintptr
	FpDest       uintptr
	FiDestSchema Tu32
	FbDestLocked int32
	FiNext       TPgno
	FpSrcDb      uintptr
	FpSrc        uintptr
	Frc          int32
	FnRemaining  TPgno
	FnPagecount  TPgno
	FisAttached  int32
	FpNext       uintptr
}

** Structure allocated for each backup operation.

type Tsqlite3_callback

type Tsqlite3_callback = uintptr

C documentation

/*
** The type for a callback function.
** This is legacy and deprecated.  It is included for historical
** compatibility and is not documented.
*/

type Tsqlite3_changegroup

type Tsqlite3_changegroup = struct {
	Frc     int32
	FbPatch int32
	FpList  uintptr
	Frec    TSessionBuffer
	Fdb     uintptr
	FzDb    uintptr
}

C documentation

/*
** CAPI3REF: Changegroup Handle
**
** A changegroup is an object used to combine two or more
** [changesets] or [patchsets]
*/

type Tsqlite3_changegroup1

type Tsqlite3_changegroup1 = struct {
	Frc     int32
	FbPatch int32
	FpList  uintptr
	Frec    TSessionBuffer
	Fdb     uintptr
	FzDb    uintptr
}

** sqlite3_changegroup handle.

type Tsqlite3_changeset_iter

type Tsqlite3_changeset_iter = struct {
	Fin         TSessionInput
	Ftblhdr     TSessionBuffer
	FbPatchset  int32
	FbInvert    int32
	FbSkipEmpty int32
	Frc         int32
	FpConflict  uintptr
	FzTab       uintptr
	FnCol       int32
	Fop         int32
	FbIndirect  int32
	FabPK       uintptr
	FapValue    uintptr
}

C documentation

/*
** CAPI3REF: Changeset Iterator Handle
**
** An instance of this object acts as a cursor for iterating
** over the elements of a [changeset] or [patchset].
*/

type Tsqlite3_changeset_iter1

type Tsqlite3_changeset_iter1 = struct {
	Fin         TSessionInput
	Ftblhdr     TSessionBuffer
	FbPatchset  int32
	FbInvert    int32
	FbSkipEmpty int32
	Frc         int32
	FpConflict  uintptr
	FzTab       uintptr
	FnCol       int32
	Fop         int32
	FbIndirect  int32
	FabPK       uintptr
	FapValue    uintptr
}

** Structure for changeset iterators.

type Tsqlite3_context

type Tsqlite3_context = struct {
	FpOut     uintptr
	FpFunc    uintptr
	FpMem     uintptr
	FpVdbe    uintptr
	FiOp      int32
	FisError  int32
	Fenc      Tu8
	FskipFlag Tu8
	Fargc     Tu8
	Fargv     [1]uintptr
}

C documentation

/*
** CAPI3REF: SQL Function Context Object
**
** The context in which an SQL function executes is stored in an
** sqlite3_context object.  ^A pointer to an sqlite3_context object
** is always first parameter to [application-defined SQL functions].
** The application-defined SQL function implementation will pass this
** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
** [sqlite3_aggregate_context()], [sqlite3_user_data()],
** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
** and/or [sqlite3_set_auxdata()].
*/

type Tsqlite3_context1

type Tsqlite3_context1 = struct {
	FpOut     uintptr
	FpFunc    uintptr
	FpMem     uintptr
	FpVdbe    uintptr
	FiOp      int32
	FisError  int32
	Fenc      Tu8
	FskipFlag Tu8
	Fargc     Tu8
	Fargv     [1]uintptr
}

** The "context" argument for an installable function. A pointer to an ** instance of this structure is the first argument to the routines used ** implement the SQL functions. ** ** There is a typedef for this structure in sqlite.h. So all routines, ** even the public interface to SQLite, can use a pointer to this structure. ** But this file is the only place where the internal details of this ** structure are known. ** ** This structure is defined inside of vdbeInt.h because it uses substructures ** (Mem) which are only defined there.

type Tsqlite3_destructor_type

type Tsqlite3_destructor_type = uintptr

C documentation

/*
** CAPI3REF: Constants Defining Special Destructor Behavior
**
** These are special values for the destructor that is passed in as the
** final argument to routines like [sqlite3_result_blob()].  ^If the destructor
** argument is SQLITE_STATIC, it means that the content pointer is constant
** and will never change.  It does not need to be destroyed.  ^The
** SQLITE_TRANSIENT value means that the content will likely change in
** the near future and that SQLite should make its own private copy of
** the content before returning.
**
** The typedef is necessary to work around problems in certain
** C++ compilers.
*/

type Tsqlite3_file

type Tsqlite3_file = struct {
	FpMethods uintptr
}

C documentation

/*
** CAPI3REF: OS Interface Open File Handle
**
** An [sqlite3_file] object represents an open file in the
** [sqlite3_vfs | OS interface layer].  Individual OS interface
** implementations will
** want to subclass this object by appending additional fields
** for their own use.  The pMethods entry is a pointer to an
** [sqlite3_io_methods] object that defines methods for performing
** I/O operations on the open file.
*/

type Tsqlite3_file1

type Tsqlite3_file1 = struct {
	FpMethods uintptr
}

type Tsqlite3_filename

type Tsqlite3_filename = uintptr

C documentation

/*
** CAPI3REF: File Name
**
** Type [sqlite3_filename] is used by SQLite to pass filenames to the
** xOpen method of a [VFS]. It may be cast to (const char*) and treated
** as a normal, nul-terminated, UTF-8 buffer containing the filename, but
** may also be passed to special APIs such as:
**
** <ul>
** <li>  sqlite3_filename_database()
** <li>  sqlite3_filename_journal()
** <li>  sqlite3_filename_wal()
** <li>  sqlite3_uri_parameter()
** <li>  sqlite3_uri_boolean()
** <li>  sqlite3_uri_int64()
** <li>  sqlite3_uri_key()
** </ul>
*/

type Tsqlite3_index_constraint

type Tsqlite3_index_constraint = struct {
	FiColumn     int32
	Fop          uint8
	Fusable      uint8
	FiTermOffset int32
}

type Tsqlite3_index_constraint_usage

type Tsqlite3_index_constraint_usage = struct {
	FargvIndex int32
	Fomit      uint8
}

type Tsqlite3_index_info

type Tsqlite3_index_info = struct {
	FnConstraint      int32
	FaConstraint      uintptr
	FnOrderBy         int32
	FaOrderBy         uintptr
	FaConstraintUsage uintptr
	FidxNum           int32
	FidxStr           uintptr
	FneedToFreeIdxStr int32
	ForderByConsumed  int32
	FestimatedCost    float64
	FestimatedRows    Tsqlite3_int64
	FidxFlags         int32
	FcolUsed          Tsqlite3_uint64
}

type Tsqlite3_index_info1

type Tsqlite3_index_info1 = struct {
	FnConstraint      int32
	FaConstraint      uintptr
	FnOrderBy         int32
	FaOrderBy         uintptr
	FaConstraintUsage uintptr
	FidxNum           int32
	FidxStr           uintptr
	FneedToFreeIdxStr int32
	ForderByConsumed  int32
	FestimatedCost    float64
	FestimatedRows    Tsqlite3_int64
	FidxFlags         int32
	FcolUsed          Tsqlite3_uint64
}

** CAPI3REF: Virtual Table Indexing Information ** KEYWORDS: sqlite3_index_info ** ** The sqlite3_index_info structure and its substructures is used as part ** of the [virtual table] interface to ** pass information into and receive the reply from the [xBestIndex] ** method of a [virtual table module]. The fields under **Inputs** are the ** inputs to xBestIndex and are read-only. xBestIndex inserts its ** results into the **Outputs** fields. ** ** ^(The aConstraint[] array records WHERE clause constraints of the form: ** ** <blockquote>column OP expr</blockquote> ** ** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^ ^(The particular operator is ** stored in aConstraint[].op using one of the ** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ ** ^(The index of the column is stored in ** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the ** expr on the right-hand side can be evaluated (and thus the constraint ** is usable) and false if it cannot.)^ ** ** ^The optimizer automatically inverts terms of the form "expr OP column" ** and makes other simplifications to the WHERE clause in an attempt to ** get as many WHERE clause terms into the form shown above as possible. ** ^The aConstraint[] array only reports WHERE clause terms that are ** relevant to the particular virtual table being queried. ** ** ^Information about the ORDER BY clause is stored in aOrderBy[]. ** ^Each term of aOrderBy records a column of the ORDER BY clause. ** ** The colUsed field indicates which columns of the virtual table may be ** required by the current scan. Virtual table columns are numbered from ** zero in the order in which they appear within the CREATE TABLE statement ** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), ** the corresponding bit is set within the colUsed mask if the column may be ** required by SQLite. If the table has at least 64 columns and any column ** to the right of the first 63 is required, then bit 63 of colUsed is also ** set. In other words, column iCol may be required if the expression ** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to ** non-zero. ** ** The [xBestIndex] method must fill aConstraintUsage[] with information ** about what parameters to pass to xFilter. ^If argvIndex>0 then ** the right-hand side of the corresponding aConstraint[] is evaluated ** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit ** is true, then the constraint is assumed to be fully handled by the ** virtual table and might not be checked again by the byte code.)^ ^(The ** aConstraintUsage[].omit flag is an optimization hint. When the omit flag ** is left in its default setting of false, the constraint will always be ** checked separately in byte code. If the omit flag is change to true, then ** the constraint may or may not be checked in byte code. In other words, ** when the omit flag is true there is no guarantee that the constraint will ** not be checked again using byte code.)^ ** ** ^The idxNum and idxStr values are recorded and passed into the ** [xFilter] method. ** ^[sqlite3_free()] is used to free idxStr if and only if ** needToFreeIdxStr is true. ** ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in ** the correct order to satisfy the ORDER BY clause so that no separate ** sorting step is required. ** ** ^The estimatedCost value is an estimate of the cost of a particular ** strategy. A cost of N indicates that the cost of the strategy is similar ** to a linear scan of an SQLite table with N rows. A cost of log(N) ** indicates that the expense of the operation is similar to that of a ** binary search on a unique indexed field of an SQLite table with N rows. ** ** ^The estimatedRows value is an estimate of the number of rows that ** will be returned by the strategy. ** ** The xBestIndex method may optionally populate the idxFlags field with a ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - ** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite ** assumes that the strategy may visit at most one row. ** ** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then ** SQLite also assumes that if a call to the xUpdate() method is made as ** part of the same statement to delete or update a virtual table row and the ** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback ** any database changes. In other words, if the xUpdate() returns ** SQLITE_CONSTRAINT, the database contents must be exactly as they were ** before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not ** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by ** the xUpdate method are automatically rolled back by SQLite. ** ** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info ** structure for SQLite [version 3.8.2] ([dateof:3.8.2]). ** If a virtual table extension is ** used with an SQLite version earlier than 3.8.2, the results of attempting ** to read or write the estimatedRows field are undefined (but are likely ** to include crashing the application). The estimatedRows field should ** therefore only be used if [sqlite3_libversion_number()] returns a ** value greater than or equal to 3008002. Similarly, the idxFlags field ** was added for [version 3.9.0] ([dateof:3.9.0]). ** It may therefore only be used if ** sqlite3_libversion_number() returns a value greater than or equal to ** 3009000.

type Tsqlite3_index_orderby

type Tsqlite3_index_orderby = struct {
	FiColumn int32
	Fdesc    uint8
}

type Tsqlite3_int64

type Tsqlite3_int64 = int64

func Xsqlite3_changes64

func Xsqlite3_changes64(tls *libc.TLS, db uintptr) (r Tsqlite3_int64)

C documentation

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

func Xsqlite3_hard_heap_limit64

func Xsqlite3_hard_heap_limit64(tls *libc.TLS, n Tsqlite3_int64) (r Tsqlite3_int64)

C documentation

/*
** Set the hard heap-size limit for the library. An argument of zero
** disables the hard heap limit.  A negative argument is a no-op used
** to obtain the return value without affecting the hard heap limit.
**
** The return value is the value of the hard heap limit just prior to
** calling this interface.
**
** Setting the hard heap limit will also activate the soft heap limit
** and constrain the soft heap limit to be no more than the hard heap
** limit.
*/

func Xsqlite3_memory_highwater

func Xsqlite3_memory_highwater(tls *libc.TLS, resetFlag int32) (r Tsqlite3_int64)

C documentation

/*
** 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 *libc.TLS) (r Tsqlite3_int64)

C documentation

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

func Xsqlite3_soft_heap_limit64

func Xsqlite3_soft_heap_limit64(tls *libc.TLS, n Tsqlite3_int64) (r Tsqlite3_int64)

C documentation

/*
** Set the soft heap-size limit for the library.  An argument of
** zero disables the limit.  A negative argument is a no-op used to
** obtain the return value.
**
** The return value is the value of the heap limit just before this
** interface was called.
**
** If the hard heap limit is enabled, then the soft heap limit cannot
** be disabled nor raised above the hard heap limit.
*/

func Xsqlite3_total_changes64

func Xsqlite3_total_changes64(tls *libc.TLS, db uintptr) (r Tsqlite3_int64)

C documentation

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

func Xsqlite3_uri_int64

func Xsqlite3_uri_int64(tls *libc.TLS, zFilename uintptr, zParam uintptr, bDflt Tsqlite3_int64) (r Tsqlite3_int64)

C documentation

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

func Xsqlite3rbu_progress

func Xsqlite3rbu_progress(tls *libc.TLS, pRbu uintptr) (r Tsqlite3_int64)

C documentation

/*
** Return the total number of key-value operations (inserts, deletes or
** updates) that have been performed on the target database since the
** current RBU update was started.
*/

func Xsqlite3rbu_temp_size

func Xsqlite3rbu_temp_size(tls *libc.TLS, pRbu uintptr) (r Tsqlite3_int64)

func Xsqlite3rbu_temp_size_limit

func Xsqlite3rbu_temp_size_limit(tls *libc.TLS, pRbu uintptr, n Tsqlite3_int64) (r Tsqlite3_int64)

C documentation

/*
** Configure the aggregate temp file size limit for this RBU handle.
*/

func Xsqlite3session_changeset_size

func Xsqlite3session_changeset_size(tls *libc.TLS, pSession uintptr) (r Tsqlite3_int64)

C documentation

/*
** Return the maximum size of sqlite3session_changeset() output.
*/

func Xsqlite3session_memory_used

func Xsqlite3session_memory_used(tls *libc.TLS, pSession uintptr) (r Tsqlite3_int64)

C documentation

/*
** Return the amount of heap memory in use.
*/

type Tsqlite3_io_methods

type Tsqlite3_io_methods = struct {
	FiVersion               int32
	FxClose                 uintptr
	FxRead                  uintptr
	FxWrite                 uintptr
	FxTruncate              uintptr
	FxSync                  uintptr
	FxFileSize              uintptr
	FxLock                  uintptr
	FxUnlock                uintptr
	FxCheckReservedLock     uintptr
	FxFileControl           uintptr
	FxSectorSize            uintptr
	FxDeviceCharacteristics uintptr
	FxShmMap                uintptr
	FxShmLock               uintptr
	FxShmBarrier            uintptr
	FxShmUnmap              uintptr
	FxFetch                 uintptr
	FxUnfetch               uintptr
}

C documentation

/*
** CAPI3REF: OS Interface File Virtual Methods Object
**
** Every file opened by the [sqlite3_vfs.xOpen] method populates an
** [sqlite3_file] object (or, more commonly, a subclass of the
** [sqlite3_file] object) with a pointer to an instance of this object.
** This object defines the methods used to perform various operations
** against the open file represented by the [sqlite3_file] object.
**
** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element
** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed.  The
** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]
** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
** to NULL.
**
** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
** The second choice is a Mac OS X style fullsync.  The [SQLITE_SYNC_DATAONLY]
** flag may be ORed in to indicate that only the data of the file
** and not its inode needs to be synced.
**
** The integer values to xLock() and xUnlock() are one of
** <ul>
** <li> [SQLITE_LOCK_NONE],
** <li> [SQLITE_LOCK_SHARED],
** <li> [SQLITE_LOCK_RESERVED],
** <li> [SQLITE_LOCK_PENDING], or
** <li> [SQLITE_LOCK_EXCLUSIVE].
** </ul>
** xLock() upgrades the database file lock.  In other words, xLock() moves the
** database file lock in the direction NONE toward EXCLUSIVE. The argument to
** xLock() is always one of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
** SQLITE_LOCK_NONE.  If the database file lock is already at or above the
** requested lock, then the call to xLock() is a no-op.
** xUnlock() downgrades the database file lock to either SHARED or NONE.
** If the lock is already at or below the requested lock state, then the call
** to xUnlock() is a no-op.
** The xCheckReservedLock() method checks whether any database connection,
** either in this process or in some other process, is holding a RESERVED,
** PENDING, or EXCLUSIVE lock on the file.  It returns true
** if such a lock exists and false otherwise.
**
** The xFileControl() method is a generic interface that allows custom
** VFS implementations to directly control an open file using the
** [sqlite3_file_control()] interface.  The second "op" argument is an
** integer opcode.  The third argument is a generic pointer intended to
** point to a structure that may contain arguments or space in which to
** write return values.  Potential uses for xFileControl() might be
** functions to enable blocking locks with timeouts, to change the
** locking strategy (for example to use dot-file locks), to inquire
** about the status of a lock, or to break stale locks.  The SQLite
** core reserves all opcodes less than 100 for its own use.
** A [file control opcodes | list of opcodes] less than 100 is available.
** Applications that define a custom xFileControl method should use opcodes
** greater than 100 to avoid conflicts.  VFS implementations should
** return [SQLITE_NOTFOUND] for file control opcodes that they do not
** recognize.
**
** The xSectorSize() method returns the sector size of the
** device that underlies the file.  The sector size is the
** minimum write that can be performed without disturbing
** other bytes in the file.  The xDeviceCharacteristics()
** method returns a bit vector describing behaviors of the
** underlying device:
**
** <ul>
** <li> [SQLITE_IOCAP_ATOMIC]
** <li> [SQLITE_IOCAP_ATOMIC512]
** <li> [SQLITE_IOCAP_ATOMIC1K]
** <li> [SQLITE_IOCAP_ATOMIC2K]
** <li> [SQLITE_IOCAP_ATOMIC4K]
** <li> [SQLITE_IOCAP_ATOMIC8K]
** <li> [SQLITE_IOCAP_ATOMIC16K]
** <li> [SQLITE_IOCAP_ATOMIC32K]
** <li> [SQLITE_IOCAP_ATOMIC64K]
** <li> [SQLITE_IOCAP_SAFE_APPEND]
** <li> [SQLITE_IOCAP_SEQUENTIAL]
** <li> [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN]
** <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE]
** <li> [SQLITE_IOCAP_IMMUTABLE]
** <li> [SQLITE_IOCAP_BATCH_ATOMIC]
** </ul>
**
** The SQLITE_IOCAP_ATOMIC property means that all writes of
** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
** mean that writes of blocks that are nnn bytes in size and
** are aligned to an address which is an integer multiple of
** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
** that when data is appended to a file, the data is appended
** first then the size of the file is extended, never the other
** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
** information is written to disk in the same order as calls
** to xWrite().
**
** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
** in the unread portions of the buffer with zeros.  A VFS that
** fails to zero-fill short reads might seem to work.  However,
** failure to zero-fill short reads will eventually lead to
** database corruption.
*/

type Tsqlite3_io_methods1

type Tsqlite3_io_methods1 = struct {
	FiVersion               int32
	FxClose                 uintptr
	FxRead                  uintptr
	FxWrite                 uintptr
	FxTruncate              uintptr
	FxSync                  uintptr
	FxFileSize              uintptr
	FxLock                  uintptr
	FxUnlock                uintptr
	FxCheckReservedLock     uintptr
	FxFileControl           uintptr
	FxSectorSize            uintptr
	FxDeviceCharacteristics uintptr
	FxShmMap                uintptr
	FxShmLock               uintptr
	FxShmBarrier            uintptr
	FxShmUnmap              uintptr
	FxFetch                 uintptr
	FxUnfetch               uintptr
}

type Tsqlite3_loadext_entry

type Tsqlite3_loadext_entry = uintptr

C documentation

/*
** This is the function signature used for all extension entry points.  It
** is also defined in the file "loadext.c".
*/

type Tsqlite3_mem_methods

type Tsqlite3_mem_methods = struct {
	FxMalloc   uintptr
	FxFree     uintptr
	FxRealloc  uintptr
	FxSize     uintptr
	FxRoundup  uintptr
	FxInit     uintptr
	FxShutdown uintptr
	FpAppData  uintptr
}

C documentation

/*
** CAPI3REF: Memory Allocation Routines
**
** An instance of this object defines the interface between SQLite
** and low-level memory allocation routines.
**
** This object is used in only one place in the SQLite interface.
** A pointer to an instance of this object is the argument to
** [sqlite3_config()] when the configuration option is
** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
** By creating an instance of this object
** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
** during configuration, an application can specify an alternative
** memory allocation subsystem for SQLite to use for all of its
** dynamic memory needs.
**
** Note that SQLite comes with several [built-in memory allocators]
** that are perfectly adequate for the overwhelming majority of applications
** and that this object is only useful to a tiny minority of applications
** with specialized memory allocation requirements.  This object is
** also used during testing of SQLite in order to specify an alternative
** memory allocator that simulates memory out-of-memory conditions in
** order to verify that SQLite recovers gracefully from such
** conditions.
**
** The xMalloc, xRealloc, and xFree methods must work like the
** malloc(), realloc() and free() functions from the standard C library.
** ^SQLite guarantees that the second argument to
** xRealloc is always a value returned by a prior call to xRoundup.
**
** xSize should return the allocated size of a memory allocation
** previously obtained from xMalloc or xRealloc.  The allocated size
** is always at least as big as the requested size but may be larger.
**
** The xRoundup method returns what would be the allocated size of
** a memory allocation given a particular requested size.  Most memory
** allocators round up memory allocations at least to the next multiple
** of 8.  Some allocators round up to a larger multiple or to a power of 2.
** Every memory allocation request coming in through [sqlite3_malloc()]
** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
** that causes the corresponding memory allocation to fail.
**
** The xInit method initializes the memory allocator.  For example,
** it might allocate any required mutexes or initialize internal data
** structures.  The xShutdown method is invoked (indirectly) by
** [sqlite3_shutdown()] and should deallocate any resources acquired
** by xInit.  The pAppData pointer is used as the only parameter to
** xInit and xShutdown.
**
** SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes
** the xInit method, so the xInit method need not be threadsafe.  The
** xShutdown method is only called from [sqlite3_shutdown()] so it does
** not need to be threadsafe either.  For all other methods, SQLite
** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
** it is by default) and so the methods are automatically serialized.
** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
** methods must be threadsafe or else make their own arrangements for
** serialization.
**
** SQLite will never invoke xInit() more than once without an intervening
** call to xShutdown().
*/

type Tsqlite3_mem_methods1

type Tsqlite3_mem_methods1 = struct {
	FxMalloc   uintptr
	FxFree     uintptr
	FxRealloc  uintptr
	FxSize     uintptr
	FxRoundup  uintptr
	FxInit     uintptr
	FxShutdown uintptr
	FpAppData  uintptr
}

type Tsqlite3_module

type Tsqlite3_module = struct {
	FiVersion      int32
	FxCreate       uintptr
	FxConnect      uintptr
	FxBestIndex    uintptr
	FxDisconnect   uintptr
	FxDestroy      uintptr
	FxOpen         uintptr
	FxClose        uintptr
	FxFilter       uintptr
	FxNext         uintptr
	FxEof          uintptr
	FxColumn       uintptr
	FxRowid        uintptr
	FxUpdate       uintptr
	FxBegin        uintptr
	FxSync         uintptr
	FxCommit       uintptr
	FxRollback     uintptr
	FxFindFunction uintptr
	FxRename       uintptr
	FxSavepoint    uintptr
	FxRelease      uintptr
	FxRollbackTo   uintptr
	FxShadowName   uintptr
	FxIntegrity    uintptr
}

type Tsqlite3_module1

type Tsqlite3_module1 = struct {
	FiVersion      int32
	FxCreate       uintptr
	FxConnect      uintptr
	FxBestIndex    uintptr
	FxDisconnect   uintptr
	FxDestroy      uintptr
	FxOpen         uintptr
	FxClose        uintptr
	FxFilter       uintptr
	FxNext         uintptr
	FxEof          uintptr
	FxColumn       uintptr
	FxRowid        uintptr
	FxUpdate       uintptr
	FxBegin        uintptr
	FxSync         uintptr
	FxCommit       uintptr
	FxRollback     uintptr
	FxFindFunction uintptr
	FxRename       uintptr
	FxSavepoint    uintptr
	FxRelease      uintptr
	FxRollbackTo   uintptr
	FxShadowName   uintptr
	FxIntegrity    uintptr
}

** CAPI3REF: Virtual Table Object ** KEYWORDS: sqlite3_module {virtual table module} ** ** This structure, sometimes called a "virtual table module", ** defines the implementation of a [virtual table]. ** This structure consists mostly of methods for the module. ** ** ^A virtual table module is created by filling in a persistent ** instance of this structure and passing a pointer to that instance ** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. ** ^The registration remains valid until it is replaced by a different ** module or until the [database connection] closes. The content ** of this structure must not change while it is registered with ** any database connection.

type Tsqlite3_mutex

type Tsqlite3_mutex = struct {
	Fmutex Tpthread_mutex_t
}

C documentation

/*
** CAPI3REF: Mutex Handle
**
** The mutex module within SQLite defines [sqlite3_mutex] to be an
** abstract type for a mutex object.  The SQLite core never looks
** at the internal representation of an [sqlite3_mutex].  It only
** deals with pointers to the [sqlite3_mutex] object.
**
** Mutexes are created using [sqlite3_mutex_alloc()].
*/

type Tsqlite3_mutex1

type Tsqlite3_mutex1 = struct {
	Fmutex Tpthread_mutex_t
}

** Each recursive mutex is an instance of the following structure.

type Tsqlite3_mutex_methods

type Tsqlite3_mutex_methods = struct {
	FxMutexInit    uintptr
	FxMutexEnd     uintptr
	FxMutexAlloc   uintptr
	FxMutexFree    uintptr
	FxMutexEnter   uintptr
	FxMutexTry     uintptr
	FxMutexLeave   uintptr
	FxMutexHeld    uintptr
	FxMutexNotheld uintptr
}

C documentation

/*
** CAPI3REF: Mutex Methods Object
**
** An instance of this structure defines the low-level routines
** used to allocate and use mutexes.
**
** Usually, the default mutex implementations provided by SQLite are
** sufficient, however the application has the option of substituting a custom
** implementation for specialized deployments or systems for which SQLite
** does not provide a suitable implementation. In this case, the application
** creates and populates an instance of this structure to pass
** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
** Additionally, an instance of this structure can be used as an
** output variable when querying the system for the current mutex
** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
**
** ^The xMutexInit method defined by this structure is invoked as
** part of system initialization by the sqlite3_initialize() function.
** ^The xMutexInit routine is called by SQLite exactly once for each
** effective call to [sqlite3_initialize()].
**
** ^The xMutexEnd method defined by this structure is invoked as
** part of system shutdown by the sqlite3_shutdown() function. The
** implementation of this method is expected to release all outstanding
** resources obtained by the mutex methods implementation, especially
** those obtained by the xMutexInit method.  ^The xMutexEnd()
** interface is invoked exactly once for each call to [sqlite3_shutdown()].
**
** ^(The remaining seven methods defined by this structure (xMutexAlloc,
** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
** xMutexNotheld) implement the following interfaces (respectively):
**
** <ul>
**   <li>  [sqlite3_mutex_alloc()] </li>
**   <li>  [sqlite3_mutex_free()] </li>
**   <li>  [sqlite3_mutex_enter()] </li>
**   <li>  [sqlite3_mutex_try()] </li>
**   <li>  [sqlite3_mutex_leave()] </li>
**   <li>  [sqlite3_mutex_held()] </li>
**   <li>  [sqlite3_mutex_notheld()] </li>
** </ul>)^
**
** The only difference is that the public sqlite3_XXX functions enumerated
** above silently ignore any invocations that pass a NULL pointer instead
** of a valid mutex handle. The implementations of the methods defined
** by this structure are not required to handle this case. The results
** of passing a NULL pointer instead of a valid mutex handle are undefined
** (i.e. it is acceptable to provide an implementation that segfaults if
** it is passed a NULL pointer).
**
** The xMutexInit() method must be threadsafe.  It must be harmless to
** invoke xMutexInit() multiple times within the same process and without
** intervening calls to xMutexEnd().  Second and subsequent calls to
** xMutexInit() must be no-ops.
**
** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
** and its associates).  Similarly, xMutexAlloc() must not use SQLite memory
** allocation for a static mutex.  ^However xMutexAlloc() may use SQLite
** memory allocation for a fast or recursive mutex.
**
** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
** called, but only if the prior call to xMutexInit returned SQLITE_OK.
** If xMutexInit fails in any way, it is expected to clean up after itself
** prior to returning.
*/

type Tsqlite3_mutex_methods1

type Tsqlite3_mutex_methods1 = struct {
	FxMutexInit    uintptr
	FxMutexEnd     uintptr
	FxMutexAlloc   uintptr
	FxMutexFree    uintptr
	FxMutexEnter   uintptr
	FxMutexTry     uintptr
	FxMutexLeave   uintptr
	FxMutexHeld    uintptr
	FxMutexNotheld uintptr
}

type Tsqlite3_pcache_methods

type Tsqlite3_pcache_methods = struct {
	FpArg       uintptr
	FxInit      uintptr
	FxShutdown  uintptr
	FxCreate    uintptr
	FxCachesize uintptr
	FxPagecount uintptr
	FxFetch     uintptr
	FxUnpin     uintptr
	FxRekey     uintptr
	FxTruncate  uintptr
	FxDestroy   uintptr
}

C documentation

/*
** This is the obsolete pcache_methods object that has now been replaced
** by sqlite3_pcache_methods2.  This object is not used by SQLite.  It is
** retained in the header file for backwards compatibility only.
*/

type Tsqlite3_pcache_methods1

type Tsqlite3_pcache_methods1 = struct {
	FpArg       uintptr
	FxInit      uintptr
	FxShutdown  uintptr
	FxCreate    uintptr
	FxCachesize uintptr
	FxPagecount uintptr
	FxFetch     uintptr
	FxUnpin     uintptr
	FxRekey     uintptr
	FxTruncate  uintptr
	FxDestroy   uintptr
}

type Tsqlite3_pcache_methods2

type Tsqlite3_pcache_methods2 = struct {
	FiVersion   int32
	FpArg       uintptr
	FxInit      uintptr
	FxShutdown  uintptr
	FxCreate    uintptr
	FxCachesize uintptr
	FxPagecount uintptr
	FxFetch     uintptr
	FxUnpin     uintptr
	FxRekey     uintptr
	FxTruncate  uintptr
	FxDestroy   uintptr
	FxShrink    uintptr
}

C documentation

/*
** CAPI3REF: Application Defined Page Cache.
** KEYWORDS: {page cache}
**
** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can
** register an alternative page cache implementation by passing in an
** instance of the sqlite3_pcache_methods2 structure.)^
** In many applications, most of the heap memory allocated by
** SQLite is used for the page cache.
** By implementing a
** custom page cache using this API, an application can better control
** the amount of memory consumed by SQLite, the way in which
** that memory is allocated and released, and the policies used to
** determine exactly which parts of a database file are cached and for
** how long.
**
** The alternative page cache mechanism is an
** extreme measure that is only needed by the most demanding applications.
** The built-in page cache is recommended for most uses.
**
** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
** internal buffer by SQLite within the call to [sqlite3_config].  Hence
** the application may discard the parameter after the call to
** [sqlite3_config()] returns.)^
**
** [[the xInit() page cache method]]
** ^(The xInit() method is called once for each effective
** call to [sqlite3_initialize()])^
** (usually only once during the lifetime of the process). ^(The xInit()
** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
** The intent of the xInit() method is to set up global data structures
** required by the custom page cache implementation.
** ^(If the xInit() method is NULL, then the
** built-in default page cache is used instead of the application defined
** page cache.)^
**
** [[the xShutdown() page cache method]]
** ^The xShutdown() method is called by [sqlite3_shutdown()].
** It can be used to clean up
** any outstanding resources before process shutdown, if required.
** ^The xShutdown() method may be NULL.
**
** ^SQLite automatically serializes calls to the xInit method,
** so the xInit method need not be threadsafe.  ^The
** xShutdown method is only called from [sqlite3_shutdown()] so it does
** not need to be threadsafe either.  All other methods must be threadsafe
** in multithreaded applications.
**
** ^SQLite will never invoke xInit() more than once without an intervening
** call to xShutdown().
**
** [[the xCreate() page cache methods]]
** ^SQLite invokes the xCreate() method to construct a new cache instance.
** SQLite will typically create one cache instance for each open database file,
** though this is not guaranteed. ^The
** first parameter, szPage, is the size in bytes of the pages that must
** be allocated by the cache.  ^szPage will always a power of two.  ^The
** second parameter szExtra is a number of bytes of extra storage
** associated with each page cache entry.  ^The szExtra parameter will
** a number less than 250.  SQLite will use the
** extra szExtra bytes on each page to store metadata about the underlying
** database page on disk.  The value passed into szExtra depends
** on the SQLite version, the target platform, and how SQLite was compiled.
** ^The third argument to xCreate(), bPurgeable, is true if the cache being
** created will be used to cache database pages of a file stored on disk, or
** false if it is used for an in-memory database. The cache implementation
** does not have to do anything special based with the value of bPurgeable;
** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
** never invoke xUnpin() except to deliberately delete a page.
** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
** false will always have the "discard" flag set to true.
** ^Hence, a cache created with bPurgeable false will
** never contain any unpinned pages.
**
** [[the xCachesize() page cache method]]
** ^(The xCachesize() method may be called at any time by SQLite to set the
** suggested maximum cache-size (number of pages stored by) the cache
** instance passed as the first argument. This is the value configured using
** the SQLite "[PRAGMA cache_size]" command.)^  As with the bPurgeable
** parameter, the implementation is not required to do anything with this
** value; it is advisory only.
**
** [[the xPagecount() page cache methods]]
** The xPagecount() method must return the number of pages currently
** stored in the cache, both pinned and unpinned.
**
** [[the xFetch() page cache methods]]
** The xFetch() method locates a page in the cache and returns a pointer to
** an sqlite3_pcache_page object associated with that page, or a NULL pointer.
** The pBuf element of the returned sqlite3_pcache_page object will be a
** pointer to a buffer of szPage bytes used to store the content of a
** single database page.  The pExtra element of sqlite3_pcache_page will be
** a pointer to the szExtra bytes of extra storage that SQLite has requested
** for each entry in the page cache.
**
** The page to be fetched is determined by the key. ^The minimum key value
** is 1.  After it has been retrieved using xFetch, the page is considered
** to be "pinned".
**
** If the requested page is already in the page cache, then the page cache
** implementation must return a pointer to the page buffer with its content
** intact.  If the requested page is not already in the cache, then the
** cache implementation should use the value of the createFlag
** parameter to help it determined what action to take:
**
** <table border=1 width=85% align=center>
** <tr><th> createFlag <th> Behavior when page is not already in cache
** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
**                 Otherwise return NULL.
** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
**                 NULL if allocating a new page is effectively impossible.
** </table>
**
** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  SQLite
** will only use a createFlag of 2 after a prior call with a createFlag of 1
** failed.)^  In between the xFetch() calls, SQLite may
** attempt to unpin one or more cache pages by spilling the content of
** pinned pages to disk and synching the operating system disk cache.
**
** [[the xUnpin() page cache method]]
** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
** as its second argument.  If the third parameter, discard, is non-zero,
** then the page must be evicted from the cache.
** ^If the discard parameter is
** zero, then the page may be discarded or retained at the discretion of
** page cache implementation. ^The page cache implementation
** may choose to evict unpinned pages at any time.
**
** The cache must not perform any reference counting. A single
** call to xUnpin() unpins the page regardless of the number of prior calls
** to xFetch().
**
** [[the xRekey() page cache methods]]
** The xRekey() method is used to change the key value associated with the
** page passed as the second argument. If the cache
** previously contains an entry associated with newKey, it must be
** discarded. ^Any prior cache entry associated with newKey is guaranteed not
** to be pinned.
**
** When SQLite calls the xTruncate() method, the cache must discard all
** existing cache entries with page numbers (keys) greater than or equal
** to the value of the iLimit parameter passed to xTruncate(). If any
** of these pages are pinned, they are implicitly unpinned, meaning that
** they can be safely discarded.
**
** [[the xDestroy() page cache method]]
** ^The xDestroy() method is used to delete a cache allocated by xCreate().
** All resources associated with the specified cache should be freed. ^After
** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
** handle invalid, and will not use it with any other sqlite3_pcache_methods2
** functions.
**
** [[the xShrink() page cache method]]
** ^SQLite invokes the xShrink() method when it wants the page cache to
** free up as much of heap memory as possible.  The page cache implementation
** is not obligated to free any memory, but well-behaved implementations should
** do their best.
*/

type Tsqlite3_pcache_methods21

type Tsqlite3_pcache_methods21 = struct {
	FiVersion   int32
	FpArg       uintptr
	FxInit      uintptr
	FxShutdown  uintptr
	FxCreate    uintptr
	FxCachesize uintptr
	FxPagecount uintptr
	FxFetch     uintptr
	FxUnpin     uintptr
	FxRekey     uintptr
	FxTruncate  uintptr
	FxDestroy   uintptr
	FxShrink    uintptr
}

type Tsqlite3_pcache_page

type Tsqlite3_pcache_page = struct {
	FpBuf   uintptr
	FpExtra uintptr
}

C documentation

/*
** CAPI3REF: Custom Page Cache Object
**
** The sqlite3_pcache_page object represents a single page in the
** page cache.  The page cache will allocate instances of this
** object.  Various methods of the page cache use pointers to instances
** of this object as parameters or as their return value.
**
** See [sqlite3_pcache_methods2] for additional information.
*/

type Tsqlite3_pcache_page1

type Tsqlite3_pcache_page1 = struct {
	FpBuf   uintptr
	FpExtra uintptr
}

type Tsqlite3_rebaser

type Tsqlite3_rebaser = struct {
	Fgrp Tsqlite3_changegroup
}

C documentation

/*
** CAPI3REF: Rebasing changesets
** EXPERIMENTAL
**
** Suppose there is a site hosting a database in state S0. And that
** modifications are made that move that database to state S1 and a
** changeset recorded (the "local" changeset). Then, a changeset based
** on S0 is received from another site (the "remote" changeset) and
** applied to the database. The database is then in state
** (S1+"remote"), where the exact state depends on any conflict
** resolution decisions (OMIT or REPLACE) made while applying "remote".
** Rebasing a changeset is to update it to take those conflict
** resolution decisions into account, so that the same conflicts
** do not have to be resolved elsewhere in the network.
**
** For example, if both the local and remote changesets contain an
** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)":
**
**   local:  INSERT INTO t1 VALUES(1, 'v1');
**   remote: INSERT INTO t1 VALUES(1, 'v2');
**
** and the conflict resolution is REPLACE, then the INSERT change is
** removed from the local changeset (it was overridden). Or, if the
** conflict resolution was "OMIT", then the local changeset is modified
** to instead contain:
**
**           UPDATE t1 SET b = 'v2' WHERE a=1;
**
** Changes within the local changeset are rebased as follows:
**
** <dl>
** <dt>Local INSERT<dd>
**   This may only conflict with a remote INSERT. If the conflict
**   resolution was OMIT, then add an UPDATE change to the rebased
**   changeset. Or, if the conflict resolution was REPLACE, add
**   nothing to the rebased changeset.
**
** <dt>Local DELETE<dd>
**   This may conflict with a remote UPDATE or DELETE. In both cases the
**   only possible resolution is OMIT. If the remote operation was a
**   DELETE, then add no change to the rebased changeset. If the remote
**   operation was an UPDATE, then the old.* fields of change are updated
**   to reflect the new.* values in the UPDATE.
**
** <dt>Local UPDATE<dd>
**   This may conflict with a remote UPDATE or DELETE. If it conflicts
**   with a DELETE, and the conflict resolution was OMIT, then the update
**   is changed into an INSERT. Any undefined values in the new.* record
**   from the update change are filled in using the old.* values from
**   the conflicting DELETE. Or, if the conflict resolution was REPLACE,
**   the UPDATE change is simply omitted from the rebased changeset.
**
**   If conflict is with a remote UPDATE and the resolution is OMIT, then
**   the old.* values are rebased using the new.* values in the remote
**   change. Or, if the resolution is REPLACE, then the change is copied
**   into the rebased changeset with updates to columns also updated by
**   the conflicting remote UPDATE removed. If this means no columns would
**   be updated, the change is omitted.
** </dl>
**
** A local change may be rebased against multiple remote changes
** simultaneously. If a single key is modified by multiple remote
** changesets, they are combined as follows before the local changeset
** is rebased:
**
** <ul>
**    <li> If there has been one or more REPLACE resolutions on a
**         key, it is rebased according to a REPLACE.
**
**    <li> If there have been no REPLACE resolutions on a key, then
**         the local changeset is rebased according to the most recent
**         of the OMIT resolutions.
** </ul>
**
** Note that conflict resolutions from multiple remote changesets are
** combined on a per-field basis, not per-row. This means that in the
** case of multiple remote UPDATE operations, some fields of a single
** local change may be rebased for REPLACE while others are rebased for
** OMIT.
**
** In order to rebase a local changeset, the remote changeset must first
** be applied to the local database using sqlite3changeset_apply_v2() and
** the buffer of rebase information captured. Then:
**
** <ol>
**   <li> An sqlite3_rebaser object is created by calling
**        sqlite3rebaser_create().
**   <li> The new object is configured with the rebase buffer obtained from
**        sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure().
**        If the local changeset is to be rebased against multiple remote
**        changesets, then sqlite3rebaser_configure() should be called
**        multiple times, in the same order that the multiple
**        sqlite3changeset_apply_v2() calls were made.
**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase().
**   <li> The sqlite3_rebaser object is deleted by calling
**        sqlite3rebaser_delete().
** </ol>
*/

type Tsqlite3_rebaser1

type Tsqlite3_rebaser1 = struct {
	Fgrp Tsqlite3_changegroup
}

** Changeset rebaser handle.

type Tsqlite3_rtree_dbl

type Tsqlite3_rtree_dbl = float64

C documentation

/* The double-precision datatype used by RTree depends on the
** SQLITE_RTREE_INT_ONLY compile-time option.
*/

type Tsqlite3_rtree_geometry

type Tsqlite3_rtree_geometry = struct {
	FpContext uintptr
	FnParam   int32
	FaParam   uintptr
	FpUser    uintptr
	FxDelUser uintptr
}

type Tsqlite3_rtree_geometry1

type Tsqlite3_rtree_geometry1 = struct {
	FpContext uintptr
	FnParam   int32
	FaParam   uintptr
	FpUser    uintptr
	FxDelUser uintptr
}

** A pointer to a structure of the following type is passed as the first ** argument to callbacks registered using rtree_geometry_callback().

type Tsqlite3_rtree_query_info

type Tsqlite3_rtree_query_info = struct {
	FpContext      uintptr
	FnParam        int32
	FaParam        uintptr
	FpUser         uintptr
	FxDelUser      uintptr
	FaCoord        uintptr
	FanQueue       uintptr
	FnCoord        int32
	FiLevel        int32
	FmxLevel       int32
	FiRowid        Tsqlite3_int64
	FrParentScore  Tsqlite3_rtree_dbl
	FeParentWithin int32
	FeWithin       int32
	FrScore        Tsqlite3_rtree_dbl
	FapSqlParam    uintptr
}

type Tsqlite3_rtree_query_info1

type Tsqlite3_rtree_query_info1 = struct {
	FpContext      uintptr
	FnParam        int32
	FaParam        uintptr
	FpUser         uintptr
	FxDelUser      uintptr
	FaCoord        uintptr
	FanQueue       uintptr
	FnCoord        int32
	FiLevel        int32
	FmxLevel       int32
	FiRowid        Tsqlite3_int64
	FrParentScore  Tsqlite3_rtree_dbl
	FeParentWithin int32
	FeWithin       int32
	FrScore        Tsqlite3_rtree_dbl
	FapSqlParam    uintptr
}

** A pointer to a structure of the following type is passed as the ** argument to scored geometry callback registered using ** sqlite3_rtree_query_callback(). ** ** Note that the first 5 fields of this structure are identical to ** sqlite3_rtree_geometry. This structure is a subclass of ** sqlite3_rtree_geometry.

type Tsqlite3_session

type Tsqlite3_session = struct {
	Fdb                uintptr
	FzDb               uintptr
	FbEnableSize       int32
	FbEnable           int32
	FbIndirect         int32
	FbAutoAttach       int32
	FbImplicitPK       int32
	Frc                int32
	FpFilterCtx        uintptr
	FxTableFilter      uintptr
	FnMalloc           Ti64
	FnMaxChangesetSize Ti64
	FpZeroBlob         uintptr
	FpNext             uintptr
	FpTable            uintptr
	Fhook              TSessionHook
}

C documentation

/*
** CAPI3REF: Session Object Handle
**
** An instance of this object is a [session] that can be used to
** record changes to a database.
*/

type Tsqlite3_session1

type Tsqlite3_session1 = struct {
	Fdb                uintptr
	FzDb               uintptr
	FbEnableSize       int32
	FbEnable           int32
	FbIndirect         int32
	FbAutoAttach       int32
	FbImplicitPK       int32
	Frc                int32
	FpFilterCtx        uintptr
	FxTableFilter      uintptr
	FnMalloc           Ti64
	FnMaxChangesetSize Ti64
	FpZeroBlob         uintptr
	FpNext             uintptr
	FpTable            uintptr
	Fhook              TSessionHook
}

** Session handle structure.

type Tsqlite3_snapshot

type Tsqlite3_snapshot = struct {
	Fhidden [48]uint8
}

C documentation

/*
** CAPI3REF: Database Snapshot
** KEYWORDS: {snapshot} {sqlite3_snapshot}
**
** An instance of the snapshot object records the state of a [WAL mode]
** database for some specific point in history.
**
** In [WAL mode], multiple [database connections] that are open on the
** same database file can each be reading a different historical version
** of the database file.  When a [database connection] begins a read
** transaction, that connection sees an unchanging copy of the database
** as it existed for the point in time when the transaction first started.
** Subsequent changes to the database from other connections are not seen
** by the reader until a new read transaction is started.
**
** The sqlite3_snapshot object records state information about an historical
** version of the database file so that it is possible to later open a new read
** transaction that sees that historical version of the database rather than
** the most recent version.
*/

type Tsqlite3_str

type Tsqlite3_str = struct {
	Fdb          uintptr
	FzText       uintptr
	FnAlloc      Tu32
	FmxAlloc     Tu32
	FnChar       Tu32
	FaccError    Tu8
	FprintfFlags Tu8
}

C documentation

/*
** CAPI3REF: Dynamic String Object
** KEYWORDS: {dynamic string}
**
** An instance of the sqlite3_str object contains a dynamically-sized
** string under construction.
**
** The lifecycle of an sqlite3_str object is as follows:
** <ol>
** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
** <li> ^Text is appended to the sqlite3_str object using various
** methods, such as [sqlite3_str_appendf()].
** <li> ^The sqlite3_str object is destroyed and the string it created
** is returned using the [sqlite3_str_finish()] interface.
** </ol>
*/

type Tsqlite3_str1

type Tsqlite3_str1 = TStrAccum

type Tsqlite3_syscall_ptr

type Tsqlite3_syscall_ptr = uintptr

type Tsqlite3_uint64

type Tsqlite3_uint64 = uint64

func Xsqlite3_msize

func Xsqlite3_msize(tls *libc.TLS, p uintptr) (r Tsqlite3_uint64)

type Tsqlite3_value

type Tsqlite3_value = struct {
	Fu        TMemValue
	Fz        uintptr
	Fn        int32
	Fflags    Tu16
	Fenc      Tu8
	FeSubtype Tu8
	Fdb       uintptr
	FszMalloc int32
	FuTemp    Tu32
	FzMalloc  uintptr
	FxDel     uintptr
}

C documentation

/*
** CAPI3REF: Dynamically Typed Value Object
** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
**
** SQLite uses the sqlite3_value object to represent all values
** that can be stored in a database table. SQLite uses dynamic typing
** for the values it stores.  ^Values stored in sqlite3_value objects
** can be integers, floating point values, strings, BLOBs, or NULL.
**
** An sqlite3_value object may be either "protected" or "unprotected".
** Some interfaces require a protected sqlite3_value.  Other interfaces
** will accept either a protected or an unprotected sqlite3_value.
** Every interface that accepts sqlite3_value arguments specifies
** whether or not it requires a protected sqlite3_value.  The
** [sqlite3_value_dup()] interface can be used to construct a new
** protected sqlite3_value from an unprotected sqlite3_value.
**
** The terms "protected" and "unprotected" refer to whether or not
** a mutex is held.  An internal mutex is held for a protected
** sqlite3_value object but no mutex is held for an unprotected
** sqlite3_value object.  If SQLite is compiled to be single-threaded
** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
** or if SQLite is run in one of reduced mutex modes
** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
** then there is no distinction between protected and unprotected
** sqlite3_value objects and they can be used interchangeably.  However,
** for maximum code portability it is recommended that applications
** still make the distinction between protected and unprotected
** sqlite3_value objects even when not strictly required.
**
** ^The sqlite3_value objects that are passed as parameters into the
** implementation of [application-defined SQL functions] are protected.
** ^The sqlite3_value objects returned by [sqlite3_vtab_rhs_value()]
** are protected.
** ^The sqlite3_value object returned by
** [sqlite3_column_value()] is unprotected.
** Unprotected sqlite3_value objects may only be used as arguments
** to [sqlite3_result_value()], [sqlite3_bind_value()], and
** [sqlite3_value_dup()].
** The [sqlite3_value_blob | sqlite3_value_type()] family of
** interfaces require protected sqlite3_value objects.
*/

type Tsqlite3_value1

type Tsqlite3_value1 = TMem

C documentation

/*
** The names of the following types declared in vdbeInt.h are required
** for the VdbeOp definition.
*/

type Tsqlite3_vfs

type Tsqlite3_vfs = struct {
	FiVersion          int32
	FszOsFile          int32
	FmxPathname        int32
	FpNext             uintptr
	FzName             uintptr
	FpAppData          uintptr
	FxOpen             uintptr
	FxDelete           uintptr
	FxAccess           uintptr
	FxFullPathname     uintptr
	FxDlOpen           uintptr
	FxDlError          uintptr
	FxDlSym            uintptr
	FxDlClose          uintptr
	FxRandomness       uintptr
	FxSleep            uintptr
	FxCurrentTime      uintptr
	FxGetLastError     uintptr
	FxCurrentTimeInt64 uintptr
	FxSetSystemCall    uintptr
	FxGetSystemCall    uintptr
	FxNextSystemCall   uintptr
}

C documentation

/*
** CAPI3REF: OS Interface Object
**
** An instance of the sqlite3_vfs object defines the interface between
** the SQLite core and the underlying operating system.  The "vfs"
** in the name of the object stands for "virtual file system".  See
** the [VFS | VFS documentation] for further information.
**
** The VFS interface is sometimes extended by adding new methods onto
** the end.  Each time such an extension occurs, the iVersion field
** is incremented.  The iVersion value started out as 1 in
** SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2
** with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased
** to 3 with SQLite [version 3.7.6] on [dateof:3.7.6].  Additional fields
** may be appended to the sqlite3_vfs object and the iVersion value
** may increase again in future versions of SQLite.
** Note that due to an oversight, the structure
** of the sqlite3_vfs object changed in the transition from
** SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0]
** and yet the iVersion field was not increased.
**
** The szOsFile field is the size of the subclassed [sqlite3_file]
** structure used by this VFS.  mxPathname is the maximum length of
** a pathname in this VFS.
**
** Registered sqlite3_vfs objects are kept on a linked list formed by
** the pNext pointer.  The [sqlite3_vfs_register()]
** and [sqlite3_vfs_unregister()] interfaces manage this list
** in a thread-safe way.  The [sqlite3_vfs_find()] interface
** searches the list.  Neither the application code nor the VFS
** implementation should use the pNext pointer.
**
** The pNext field is the only field in the sqlite3_vfs
** structure that SQLite will ever modify.  SQLite will only access
** or modify this field while holding a particular static mutex.
** The application should never modify anything within the sqlite3_vfs
** object once the object has been registered.
**
** The zName field holds the name of the VFS module.  The name must
** be unique across all VFS modules.
**
** [[sqlite3_vfs.xOpen]]
** ^SQLite guarantees that the zFilename parameter to xOpen
** is either a NULL pointer or string obtained
** from xFullPathname() with an optional suffix added.
** ^If a suffix is added to the zFilename parameter, it will
** consist of a single "-" character followed by no more than
** 11 alphanumeric and/or "-" characters.
** ^SQLite further guarantees that
** the string will be valid and unchanged until xClose() is
** called. Because of the previous sentence,
** the [sqlite3_file] can safely store a pointer to the
** filename if it needs to remember the filename for some reason.
** If the zFilename parameter to xOpen is a NULL pointer then xOpen
** must invent its own temporary name for the file.  ^Whenever the
** xFilename parameter is NULL it will also be the case that the
** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
**
** The flags argument to xOpen() includes all bits set in
** the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
** or [sqlite3_open16()] is used, then flags includes at least
** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
** If xOpen() opens a file read-only then it sets *pOutFlags to
** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.
**
** ^(SQLite will also add one of the following flags to the xOpen()
** call, depending on the object being opened:
**
** <ul>
** <li>  [SQLITE_OPEN_MAIN_DB]
** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
** <li>  [SQLITE_OPEN_TEMP_DB]
** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
** <li>  [SQLITE_OPEN_TRANSIENT_DB]
** <li>  [SQLITE_OPEN_SUBJOURNAL]
** <li>  [SQLITE_OPEN_SUPER_JOURNAL]
** <li>  [SQLITE_OPEN_WAL]
** </ul>)^
**
** The file I/O implementation can use the object type flags to
** change the way it deals with files.  For example, an application
** that does not care about crash recovery or rollback might make
** the open of a journal file a no-op.  Writes to this journal would
** also be no-ops, and any attempt to read the journal would return
** SQLITE_IOERR.  Or the implementation might recognize that a database
** file will be doing page-aligned sector reads and writes in a random
** order and set up its I/O subsystem accordingly.
**
** SQLite might also add one of the following flags to the xOpen method:
**
** <ul>
** <li> [SQLITE_OPEN_DELETEONCLOSE]
** <li> [SQLITE_OPEN_EXCLUSIVE]
** </ul>
**
** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
** deleted when it is closed.  ^The [SQLITE_OPEN_DELETEONCLOSE]
** will be set for TEMP databases and their journals, transient
** databases, and subjournals.
**
** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
** with the [SQLITE_OPEN_CREATE] flag, which are both directly
** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
** API.  The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
** SQLITE_OPEN_CREATE, is used to indicate that file should always
** be created, and that it is an error if it already exists.
** It is <i>not</i> used to indicate the file should be opened
** for exclusive access.
**
** ^At least szOsFile bytes of memory are allocated by SQLite
** to hold the [sqlite3_file] structure passed as the third
** argument to xOpen.  The xOpen method does not have to
** allocate the structure; it should just fill it in.  Note that
** the xOpen method must set the sqlite3_file.pMethods to either
** a valid [sqlite3_io_methods] object or to NULL.  xOpen must do
** this even if the open fails.  SQLite expects that the sqlite3_file.pMethods
** element will be valid after xOpen returns regardless of the success
** or failure of the xOpen call.
**
** [[sqlite3_vfs.xAccess]]
** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
** to test whether a file is at least readable.  The SQLITE_ACCESS_READ
** flag is never actually used and is not implemented in the built-in
** VFSes of SQLite.  The file is named by the second argument and can be a
** directory. The xAccess method returns [SQLITE_OK] on success or some
** non-zero error code if there is an I/O error or if the name of
** the file given in the second argument is illegal.  If SQLITE_OK
** is returned, then non-zero or zero is written into *pResOut to indicate
** whether or not the file is accessible.
**
** ^SQLite will always allocate at least mxPathname+1 bytes for the
** output buffer xFullPathname.  The exact size of the output buffer
** is also passed as a parameter to both  methods. If the output buffer
** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
** handled as a fatal error by SQLite, vfs implementations should endeavor
** to prevent this by setting mxPathname to a sufficiently large value.
**
** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
** interfaces are not strictly a part of the filesystem, but they are
** included in the VFS structure for completeness.
** The xRandomness() function attempts to return nBytes bytes
** of good-quality randomness into zOut.  The return value is
** the actual number of bytes of randomness obtained.
** The xSleep() method causes the calling thread to sleep for at
** least the number of microseconds given.  ^The xCurrentTime()
** method returns a Julian Day Number for the current date and time as
** a floating point value.
** ^The xCurrentTimeInt64() method returns, as an integer, the Julian
** Day Number multiplied by 86400000 (the number of milliseconds in
** a 24-hour day).
** ^SQLite will use the xCurrentTimeInt64() method to get the current
** date and time if that method is available (if iVersion is 2 or
** greater and the function pointer is not NULL) and will fall back
** to xCurrentTime() if xCurrentTimeInt64() is unavailable.
**
** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
** are not used by the SQLite core.  These optional interfaces are provided
** by some VFSes to facilitate testing of the VFS code. By overriding
** system calls with functions under its control, a test program can
** simulate faults and error conditions that would otherwise be difficult
** or impossible to induce.  The set of system calls that can be overridden
** varies from one VFS to another, and from one version of the same VFS to the
** next.  Applications that use these interfaces must be prepared for any
** or all of these interfaces to be NULL or for their behavior to change
** from one release to the next.  Applications must not attempt to access
** any of these methods if the iVersion of the VFS is less than 3.
*/

type Tsqlite3_vfs1

type Tsqlite3_vfs1 = struct {
	FiVersion          int32
	FszOsFile          int32
	FmxPathname        int32
	FpNext             uintptr
	FzName             uintptr
	FpAppData          uintptr
	FxOpen             uintptr
	FxDelete           uintptr
	FxAccess           uintptr
	FxFullPathname     uintptr
	FxDlOpen           uintptr
	FxDlError          uintptr
	FxDlSym            uintptr
	FxDlClose          uintptr
	FxRandomness       uintptr
	FxSleep            uintptr
	FxCurrentTime      uintptr
	FxGetLastError     uintptr
	FxCurrentTimeInt64 uintptr
	FxSetSystemCall    uintptr
	FxGetSystemCall    uintptr
	FxNextSystemCall   uintptr
}

type Tsqlite3_vtab

type Tsqlite3_vtab = struct {
	FpModule uintptr
	FnRef    int32
	FzErrMsg uintptr
}

C documentation

/*
** Structures used by the virtual table interface
*/

type Tsqlite3_vtab1

type Tsqlite3_vtab1 = struct {
	FpModule uintptr
	FnRef    int32
	FzErrMsg uintptr
}

** CAPI3REF: Virtual Table Instance Object ** KEYWORDS: sqlite3_vtab ** ** Every [virtual table module] implementation uses a subclass ** of this object to describe a particular instance ** of the [virtual table]. Each subclass will ** be tailored to the specific needs of the module implementation. ** The purpose of this superclass is to define certain fields that are ** common to all module implementations. ** ** ^Virtual tables methods can set an error message by assigning a ** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should ** take care that any prior string is freed by a call to [sqlite3_free()] ** prior to assigning a new string to zErrMsg. ^After the error message ** is delivered up to the client application, the string will be automatically ** freed by sqlite3_free() and the zErrMsg field will be zeroed.

type Tsqlite3_vtab_cursor

type Tsqlite3_vtab_cursor = struct {
	FpVtab uintptr
}

type Tsqlite3_vtab_cursor1

type Tsqlite3_vtab_cursor1 = struct {
	FpVtab uintptr
}

** CAPI3REF: Virtual Table Cursor Object ** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} ** ** Every [virtual table module] implementation uses a subclass of the ** following structure to describe cursors that point into the ** [virtual table] and are used ** to loop through the virtual table. Cursors are created using the ** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed ** by the [sqlite3_module.xClose | xClose] method. Cursors are used ** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods ** of the module. Each module implementation will define ** the content of a cursor structure to suit its own needs. ** ** This superclass exists in order to define fields of the cursor that ** are common to all implementations.

type Tsqlite3_xauth

type Tsqlite3_xauth = uintptr

C documentation

/*
** typedef for the authorization callback function.
*/

type Tsqlite3rbu

type Tsqlite3rbu = struct {
	FeStage         int32
	FdbMain         uintptr
	FdbRbu          uintptr
	FzTarget        uintptr
	FzRbu           uintptr
	FzState         uintptr
	FzStateDb       [5]int8
	Frc             int32
	FzErrmsg        uintptr
	FnStep          int32
	FnProgress      int32
	Fobjiter        TRbuObjIter
	FzVfsName       uintptr
	FpTargetFd      uintptr
	FnPagePerSector int32
	FiOalSz         Ti64
	FnPhaseOneStep  Ti64
	FpRenameArg     uintptr
	FxRename        uintptr
	FiMaxFrame      Tu32
	FmLock          Tu32
	FnFrame         int32
	FnFrameAlloc    int32
	FaFrame         uintptr
	Fpgsz           int32
	FaBuf           uintptr
	FiWalCksum      Ti64
	FszTemp         Ti64
	FszTempLimit    Ti64
	FnRbu           int32
	FpRbuFd         uintptr
}

type Tsqlite3rbu1

type Tsqlite3rbu1 = struct {
	FeStage         int32
	FdbMain         uintptr
	FdbRbu          uintptr
	FzTarget        uintptr
	FzRbu           uintptr
	FzState         uintptr
	FzStateDb       [5]int8
	Frc             int32
	FzErrmsg        uintptr
	FnStep          int32
	FnProgress      int32
	Fobjiter        TRbuObjIter
	FzVfsName       uintptr
	FpTargetFd      uintptr
	FnPagePerSector int32
	FiOalSz         Ti64
	FnPhaseOneStep  Ti64
	FpRenameArg     uintptr
	FxRename        uintptr
	FiMaxFrame      Tu32
	FmLock          Tu32
	FnFrame         int32
	FnFrameAlloc    int32
	FaFrame         uintptr
	Fpgsz           int32
	FaBuf           uintptr
	FiWalCksum      Ti64
	FszTemp         Ti64
	FszTempLimit    Ti64
	FnRbu           int32
	FpRbuFd         uintptr
}

** RBU handle. ** ** nPhaseOneStep: ** If the RBU database contains an rbu_count table, this value is set to ** a running estimate of the number of b-tree operations required to ** finish populating the *-oal file. This allows the sqlite3_bp_progress() ** API to calculate the permyriadage progress of populating the *-oal file ** using the formula: ** ** permyriadage = (10000 * nProgress) / nPhaseOneStep ** ** nPhaseOneStep is initialized to the sum of: ** ** nRow * (nIndex + 1) ** ** for all source tables in the RBU database, where nRow is the number ** of rows in the source table and nIndex the number of indexes on the ** corresponding target database table. ** ** This estimate is accurate if the RBU update consists entirely of ** INSERT operations. However, it is inaccurate if: ** ** * the RBU update contains any UPDATE operations. If the PK specified ** for an UPDATE operation does not exist in the target table, then ** no b-tree operations are required on index b-trees. Or if the ** specified PK does exist, then (nIndex*2) such operations are ** required (one delete and one insert on each index b-tree). ** ** * the RBU update contains any DELETE operations for which the specified ** PK does not exist. In this case no operations are required on index ** b-trees. ** ** * the RBU update contains REPLACE operations. These are similar to ** UPDATE operations. ** ** nPhaseOneStep is updated to account for the conditions above during the ** first pass of each source table. The updated nPhaseOneStep value is ** stored in the rbu_state table if the RBU update is suspended.

type Tsqlite_int64

type Tsqlite_int64 = int64

C documentation

/*
** CAPI3REF: 64-Bit Integer Types
** KEYWORDS: sqlite_int64 sqlite_uint64
**
** Because there is no cross-platform way to specify 64-bit integer types
** SQLite includes typedefs for 64-bit signed and unsigned integers.
**
** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
** The sqlite_int64 and sqlite_uint64 types are supported for backwards
** compatibility only.
**
** ^The sqlite3_int64 and sqlite_int64 types can store integer values
** between -9223372036854775808 and +9223372036854775807 inclusive.  ^The
** sqlite3_uint64 and sqlite_uint64 types can store integer values
** between 0 and +18446744073709551615 inclusive.
*/

func Xsqlite3_column_int64

func Xsqlite3_column_int64(tls *libc.TLS, pStmt uintptr, i int32) (r Tsqlite_int64)

func Xsqlite3_last_insert_rowid

func Xsqlite3_last_insert_rowid(tls *libc.TLS, db uintptr) (r Tsqlite_int64)

C documentation

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

func Xsqlite3_value_int64

func Xsqlite3_value_int64(tls *libc.TLS, pVal uintptr) (r Tsqlite_int64)

type Tsqlite_uint64

type Tsqlite_uint64 = uint64

type Tssize_t

type Tssize_t = int64

type Tstat

type Tstat = struct {
	Fst_dev     Tdev_t
	Fst_ino     Tino_t
	Fst_nlink   Tnlink_t
	Fst_mode    Tmode_t
	Fst_uid     Tuid_t
	Fst_gid     Tgid_t
	F__pad0     uint32
	Fst_rdev    Tdev_t
	Fst_size    Toff_t
	Fst_blksize Tblksize_t
	Fst_blocks  Tblkcnt_t
	Fst_atim    Ttimespec
	Fst_mtim    Ttimespec
	Fst_ctim    Ttimespec
	F__unused   [3]int64
}

type Tstatx

type Tstatx = struct {
	Fstx_mask            Tuint32_t
	Fstx_blksize         Tuint32_t
	Fstx_attributes      Tuint64_t
	Fstx_nlink           Tuint32_t
	Fstx_uid             Tuint32_t
	Fstx_gid             Tuint32_t
	Fstx_mode            Tuint16_t
	F__pad0              [1]Tuint16_t
	Fstx_ino             Tuint64_t
	Fstx_size            Tuint64_t
	Fstx_blocks          Tuint64_t
	Fstx_attributes_mask Tuint64_t
	Fstx_atime           Tstatx_timestamp
	Fstx_btime           Tstatx_timestamp
	Fstx_ctime           Tstatx_timestamp
	Fstx_mtime           Tstatx_timestamp
	Fstx_rdev_major      Tuint32_t
	Fstx_rdev_minor      Tuint32_t
	Fstx_dev_major       Tuint32_t
	Fstx_dev_minor       Tuint32_t
	F__pad1              [14]Tuint64_t
}

type Tstatx_timestamp

type Tstatx_timestamp = struct {
	Ftv_sec  Tint64_t
	Ftv_nsec Tuint32_t
	F__pad   Tuint32_t
}

type Tsuseconds_t

type Tsuseconds_t = int64

type TtRowcnt

type TtRowcnt = uint64

C documentation

/*
** The datatype used to store estimates of the number of rows in a
** table or index.
*/

type Ttime_t

type Ttime_t = int64

type Ttimer_t

type Ttimer_t = uintptr

type Ttimespec

type Ttimespec = struct {
	Ftv_sec  Ttime_t
	Ftv_nsec int64
}

type Ttimeval

type Ttimeval = struct {
	Ftv_sec  Ttime_t
	Ftv_usec Tsuseconds_t
}

type Ttimezone

type Ttimezone = struct {
	Ftz_minuteswest int32
	Ftz_dsttime     int32
}

type Ttm

type Ttm = struct {
	Ftm_sec    int32
	Ftm_min    int32
	Ftm_hour   int32
	Ftm_mday   int32
	Ftm_mon    int32
	Ftm_year   int32
	Ftm_wday   int32
	Ftm_yday   int32
	Ftm_isdst  int32
	Ftm_gmtoff int64
	Ftm_zone   uintptr
}

type Tu16

type Tu16 = uint16

4-byte unsigned integer

type Tu32

type Tu32 = uint32

8-byte unsigned integer

type Tu64

type Tu64 = uint64

8-byte signed integer

type Tu8

type Tu8 = uint8

2-byte signed integer

type Tu_char

type Tu_char = uint8

type Tu_int

type Tu_int = uint32

type Tu_int16_t

type Tu_int16_t = uint16

type Tu_int32_t

type Tu_int32_t = uint32

type Tu_int64_t

type Tu_int64_t = uint64

type Tu_int8_t

type Tu_int8_t = uint8

type Tu_long

type Tu_long = uint64

type Tu_quad_t

type Tu_quad_t = uint64

type Tu_short

type Tu_short = uint16

type Tuid_t

type Tuid_t = uint32

type Tuint

type Tuint = uint32

type Tuint16_t

type Tuint16_t = uint16

type Tuint32_t

type Tuint32_t = uint32

type Tuint64_t

type Tuint64_t = uint64

type Tulong

type Tulong = uint64

type TunixFile

type TunixFile = struct {
	FpMethod               uintptr
	FpVfs                  uintptr
	FpInode                uintptr
	Fh                     int32
	FeFileLock             uint8
	FctrlFlags             uint16
	FlastErrno             int32
	FlockingContext        uintptr
	FpPreallocatedUnused   uintptr
	FzPath                 uintptr
	FpShm                  uintptr
	FszChunk               int32
	FnFetchOut             int32
	FmmapSize              Tsqlite3_int64
	FmmapSizeActual        Tsqlite3_int64
	FmmapSizeMax           Tsqlite3_int64
	FpMapRegion            uintptr
	FsectorSize            int32
	FdeviceCharacteristics int32
}

C documentation

/*
** The unixFile structure is subclass of sqlite3_file specific to the unix
** VFS implementations.
*/

type TunixFile1

type TunixFile1 = struct {
	FpMethod               uintptr
	FpVfs                  uintptr
	FpInode                uintptr
	Fh                     int32
	FeFileLock             uint8
	FctrlFlags             uint16
	FlastErrno             int32
	FlockingContext        uintptr
	FpPreallocatedUnused   uintptr
	FzPath                 uintptr
	FpShm                  uintptr
	FszChunk               int32
	FnFetchOut             int32
	FmmapSize              Tsqlite3_int64
	FmmapSizeActual        Tsqlite3_int64
	FmmapSizeMax           Tsqlite3_int64
	FpMapRegion            uintptr
	FsectorSize            int32
	FdeviceCharacteristics int32
}

type TunixFileId

type TunixFileId = struct {
	Fdev Tdev_t
	Fino Tu64
}

** An instance of the following structure serves as the key used ** to locate a particular unixInodeInfo object.

type TunixInodeInfo

type TunixInodeInfo = struct {
	FfileId       TunixFileId
	FpLockMutex   uintptr
	FnShared      int32
	FnLock        int32
	FeFileLock    uint8
	FbProcessLock uint8
	FpUnused      uintptr
	FnRef         int32
	FpShmNode     uintptr
	FpNext        uintptr
	FpPrev        uintptr
}

Shared memory instance

type TunixInodeInfo1

type TunixInodeInfo1 = struct {
	FfileId       TunixFileId
	FpLockMutex   uintptr
	FnShared      int32
	FnLock        int32
	FeFileLock    uint8
	FbProcessLock uint8
	FpUnused      uintptr
	FnRef         int32
	FpShmNode     uintptr
	FpNext        uintptr
	FpPrev        uintptr
}

** An instance of the following structure is allocated for each open ** inode. ** ** A single inode can have multiple file descriptors, so each unixFile ** structure contains a pointer to an instance of this object and this ** object keeps a count of the number of unixFile pointing to it. ** ** Mutex rules: ** ** (1) Only the pLockMutex mutex must be held in order to read or write ** any of the locking fields: ** nShared, nLock, eFileLock, bProcessLock, pUnused ** ** (2) When nRef>0, then the following fields are unchanging and can ** be read (but not written) without holding any mutex: ** fileId, pLockMutex ** ** (3) With the exceptions above, all the fields may only be read ** or written while holding the global unixBigLock mutex. ** ** Deadlock prevention: The global unixBigLock mutex may not ** be acquired while holding the pLockMutex mutex. If both unixBigLock ** and pLockMutex are needed, then unixBigLock must be acquired first.

type TunixShm

type TunixShm = struct {
	FpShmNode   uintptr
	FpNext      uintptr
	FhasMutex   Tu8
	Fid         Tu8
	FsharedMask Tu16
	FexclMask   Tu16
}

C documentation

/* Forward references */

type TunixShm1

type TunixShm1 = struct {
	FpShmNode   uintptr
	FpNext      uintptr
	FhasMutex   Tu8
	Fid         Tu8
	FsharedMask Tu16
	FexclMask   Tu16
}

** Structure used internally by this VFS to record the state of an ** open shared memory connection. ** ** The following fields are initialized when this object is created and ** are read-only thereafter: ** ** unixShm.pShmNode ** unixShm.id ** ** All other fields are read/write. The unixShm.pShmNode->pShmMutex must ** be held while accessing any read/write fields.

type TunixShmNode

type TunixShmNode = struct {
	FpInode     uintptr
	FpShmMutex  uintptr
	FzFilename  uintptr
	FhShm       int32
	FszRegion   int32
	FnRegion    Tu16
	FisReadonly Tu8
	FisUnlocked Tu8
	FapRegion   uintptr
	FnRef       int32
	FpFirst     uintptr
	FaLock      [8]int32
}

Connection shared memory

type TunixShmNode1

type TunixShmNode1 = struct {
	FpInode     uintptr
	FpShmMutex  uintptr
	FzFilename  uintptr
	FhShm       int32
	FszRegion   int32
	FnRegion    Tu16
	FisReadonly Tu8
	FisUnlocked Tu8
	FapRegion   uintptr
	FnRef       int32
	FpFirst     uintptr
	FaLock      [8]int32
}

** Object used to represent an shared memory buffer. ** ** When multiple threads all reference the same wal-index, each thread ** has its own unixShm object, but they all point to a single instance ** of this unixShmNode object. In other words, each wal-index is opened ** only once per process. ** ** Each unixShmNode object is connected to a single unixInodeInfo object. ** We could coalesce this object into unixInodeInfo, but that would mean ** every open file that does not use shared memory (in other words, most ** open files) would have to carry around this extra information. So ** the unixInodeInfo object contains a pointer to this unixShmNode object ** and the unixShmNode object is created only when needed. ** ** unixMutexHeld() must be true when creating or destroying ** this object or while reading or writing the following fields: ** ** nRef ** ** The following fields are read-only after the object is created: ** ** hShm ** zFilename ** ** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and ** unixMutexHeld() is true when reading or writing any other field ** in this structure. ** ** aLock[SQLITE_SHM_NLOCK]: ** This array records the various locks held by clients on each of the ** SQLITE_SHM_NLOCK slots. If the aLock[] entry is set to 0, then no ** locks are held by the process on this slot. If it is set to -1, then ** some client holds an EXCLUSIVE lock on the locking slot. If the aLock[] ** value is set to a positive value, then it is the number of shared ** locks currently held on the slot. ** ** aMutex[SQLITE_SHM_NLOCK]: ** Normally, when SQLITE_ENABLE_SETLK_TIMEOUT is not defined, mutex ** pShmMutex is used to protect the aLock[] array and the right to ** call fcntl() on unixShmNode.hShm to obtain or release locks. ** ** If SQLITE_ENABLE_SETLK_TIMEOUT is defined though, we use an array ** of mutexes - one for each locking slot. To read or write locking ** slot aLock[iSlot], the caller must hold the corresponding mutex ** aMutex[iSlot]. Similarly, to call fcntl() to obtain or release a ** lock corresponding to slot iSlot, mutex aMutex[iSlot] must be held.

type Tunix_syscall

type Tunix_syscall = struct {
	FzName    uintptr
	FpCurrent Tsqlite3_syscall_ptr
	FpDefault Tsqlite3_syscall_ptr
}

C documentation

/*
** Many system calls are accessed through pointer-to-functions so that
** they may be overridden at runtime to facilitate fault injection during
** testing and sandboxing.  The following array holds the names and pointers
** to all overrideable system calls.
*/

type Tuptr

type Tuptr = uint64

C documentation

/* The uptr type is an unsigned integer large enough to hold a pointer
*/

type Tuseconds_t

type Tuseconds_t = uint32

type Tushort

type Tushort = uint16

type Tva_list

type Tva_list = uintptr

type TvxworksFileId

type TvxworksFileId = struct {
	FpNext          uintptr
	FnRef           int32
	FnName          int32
	FzCanonicalName uintptr
}

***************************************************************************** ****************** Begin Unique File ID Utility Used By VxWorks *************** ** ** On most versions of unix, we can get a unique ID for a file by concatenating ** the device number and the inode number. But this does not work on VxWorks. ** On VxWorks, a unique file id must be based on the canonical filename. ** ** A pointer to an instance of the following structure can be used as a ** unique file ID in VxWorks. Each instance of this structure contains ** a copy of the canonical filename. There is also a reference count. ** The structure is reclaimed when the number of pointers to it drops to ** zero. ** ** There are never very many files open at one time and lookups are not ** a performance-critical path, so it is sufficient to put these ** structures on a linked list.

type Twchar_t

type Twchar_t = int32

type Twinsize

type Twinsize = struct {
	Fws_row    uint16
	Fws_col    uint16
	Fws_xpixel uint16
	Fws_ypixel uint16
}

type TyDbMask

type TyDbMask = uint32

C documentation

/*
** The yDbMask datatype for the bitmask of all attached databases.
*/

type TynVar

type TynVar = int16

C documentation

/*
** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
** Usually it is 16-bits.  But if SQLITE_MAX_VARIABLE_NUMBER is greater
** than 32767 we have to make it 32-bit.  16-bit is preferred because
** it uses less memory in the Expr object, which is a big memory user
** in systems with lots of prepared statements.  And few applications
** need more than about 10 or 20 variables.  But some extreme users want
** to have prepared statements with over 32766 variables, and for them
** the option is available (at compile-time).
*/

type TyyParser

type TyyParser = struct {
	Fyytos      uintptr
	FpParse     uintptr
	FyystackEnd uintptr
	Fyystack    uintptr
	Fyystk0     [100]TyyStackEntry
}

type TyyParser1

type TyyParser1 = struct {
	Fyytos      uintptr
	FpParse     uintptr
	FyystackEnd uintptr
	Fyystack    uintptr
	Fyystk0     [100]TyyStackEntry
}

The state of the parser is completely contained in an instance of

** the following structure

type TyyStackEntry

type TyyStackEntry = struct {
	Fstateno uint16
	Fmajor   uint16
	Fminor   TYYMINORTYPE
}

type TyyStackEntry1

type TyyStackEntry1 = struct {
	Fstateno uint16
	Fmajor   uint16
	Fminor   TYYMINORTYPE
}

The following structure represents a single element of the

** parser's stack. Information stored includes: ** ** + The state number for the parser at this level of the stack. ** ** + The value of the token stored at this level of the stack. ** (In other words, the "major" token.) ** ** + The semantic value stored at this level of the stack. This is ** the information used by the action routines in the grammar. ** It is sometimes called the "minor" token. ** ** After the "shift" half of a SHIFTREDUCE action, the stateno field ** actually contains the reduce action for the second half of the ** SHIFTREDUCE.

type Unicode61Tokenizer

type Unicode61Tokenizer = TUnicode61Tokenizer

type Unicode61Tokenizer1

type Unicode61Tokenizer1 = TUnicode61Tokenizer1

type UnixUnusedFd

type UnixUnusedFd = TUnixUnusedFd

type UnixUnusedFd1

type UnixUnusedFd1 = TUnixUnusedFd1

type UnpackedRecord

type UnpackedRecord = TUnpackedRecord

type UnpackedRecord1

type UnpackedRecord1 = TUnpackedRecord1

type Upsert

type Upsert = TUpsert

type Upsert1

type Upsert1 = TUpsert1

type VList

type VList = TVList

type VTable

type VTable = TVTable

type VTable1

type VTable1 = TVTable1

type ValueList

type ValueList = TValueList

type ValueList1

type ValueList1 = TValueList1

type ValueNewStat4Ctx

type ValueNewStat4Ctx = TValueNewStat4Ctx

type Vdbe

type Vdbe = TVdbe

type Vdbe1

type Vdbe1 = TVdbe1

type VdbeCursor

type VdbeCursor = TVdbeCursor

type VdbeCursor1

type VdbeCursor1 = TVdbeCursor1

type VdbeFrame

type VdbeFrame = TVdbeFrame

type VdbeFrame1

type VdbeFrame1 = TVdbeFrame1

type VdbeOp

type VdbeOp = TVdbeOp

type VdbeOp1

type VdbeOp1 = TVdbeOp1

type VdbeOpList

type VdbeOpList = TVdbeOpList

type VdbeOpList1

type VdbeOpList1 = TVdbeOpList1

type VdbeSorter

type VdbeSorter = TVdbeSorter

type VdbeSorter1

type VdbeSorter1 = TVdbeSorter1

type VdbeTxtBlbCache

type VdbeTxtBlbCache = TVdbeTxtBlbCache

type VdbeTxtBlbCache1

type VdbeTxtBlbCache1 = TVdbeTxtBlbCache1

type VtabCtx

type VtabCtx = TVtabCtx

type VtabCtx1

type VtabCtx1 = TVtabCtx1

type Wal

type Wal = TWal

type Wal1

type Wal1 = TWal1

type WalCkptInfo

type WalCkptInfo = TWalCkptInfo

type WalCkptInfo1

type WalCkptInfo1 = TWalCkptInfo1

type WalHashLoc

type WalHashLoc = TWalHashLoc

type WalHashLoc1

type WalHashLoc1 = TWalHashLoc1

type WalIndexHdr

type WalIndexHdr = TWalIndexHdr

type WalIndexHdr1

type WalIndexHdr1 = TWalIndexHdr1

type WalIterator

type WalIterator = TWalIterator

type WalIterator1

type WalIterator1 = TWalIterator1

type WalSegment

type WalSegment = TWalSegment

type WalWriter

type WalWriter = TWalWriter

type Walker

type Walker = TWalker

type Walker1

type Walker1 = TWalker1

type WhereAndInfo

type WhereAndInfo = TWhereAndInfo

type WhereAndInfo1

type WhereAndInfo1 = TWhereAndInfo1

type WhereClause

type WhereClause = TWhereClause

type WhereClause1

type WhereClause1 = TWhereClause1

type WhereConst

type WhereConst = TWhereConst

type WhereConst1

type WhereConst1 = TWhereConst1

type WhereInfo

type WhereInfo = TWhereInfo

type WhereInfo1

type WhereInfo1 = TWhereInfo1

type WhereLevel

type WhereLevel = TWhereLevel

type WhereLevel1

type WhereLevel1 = TWhereLevel1

type WhereLoop

type WhereLoop = TWhereLoop

type WhereLoop1

type WhereLoop1 = TWhereLoop1

type WhereLoopBuilder

type WhereLoopBuilder = TWhereLoopBuilder

type WhereLoopBuilder1

type WhereLoopBuilder1 = TWhereLoopBuilder1

type WhereMaskSet

type WhereMaskSet = TWhereMaskSet

type WhereMaskSet1

type WhereMaskSet1 = TWhereMaskSet1

type WhereMemBlock

type WhereMemBlock = TWhereMemBlock

type WhereMemBlock1

type WhereMemBlock1 = TWhereMemBlock1

type WhereOrCost

type WhereOrCost = TWhereOrCost

type WhereOrCost1

type WhereOrCost1 = TWhereOrCost1

type WhereOrInfo

type WhereOrInfo = TWhereOrInfo

type WhereOrInfo1

type WhereOrInfo1 = TWhereOrInfo1

type WhereOrSet

type WhereOrSet = TWhereOrSet

type WhereOrSet1

type WhereOrSet1 = TWhereOrSet1

type WherePath

type WherePath = TWherePath

type WherePath1

type WherePath1 = TWherePath1

type WhereRightJoin

type WhereRightJoin = TWhereRightJoin

type WhereRightJoin1

type WhereRightJoin1 = TWhereRightJoin1

type WhereScan

type WhereScan = TWhereScan

type WhereScan1

type WhereScan1 = TWhereScan1

type WhereTerm

type WhereTerm = TWhereTerm

type WhereTerm1

type WhereTerm1 = TWhereTerm1

type Window

type Window = TWindow

type Window1

type Window1 = TWindow1

type WindowCodeArg

type WindowCodeArg = TWindowCodeArg

type WindowCodeArg1

type WindowCodeArg1 = TWindowCodeArg1

type WindowCsrAndReg

type WindowCsrAndReg = TWindowCsrAndReg

type WindowCsrAndReg1

type WindowCsrAndReg1 = TWindowCsrAndReg1

type WindowRewrite

type WindowRewrite = TWindowRewrite

type WindowRewrite1

type WindowRewrite1 = TWindowRewrite1

type With

type With = TWith

type With1

type With1 = TWith1

type YYMINORTYPE

type YYMINORTYPE = TYYMINORTYPE