package sqlite when ODIN_OS == .Windows { foreign import sqlite "lib/sqlite3.lib" } else when ODIN_OS == .Darwin { when ODIN_ARCH == .arm64 { foreign import sqlite "lib/libsqlite3_arm64.a" } else when ODIN_ARCH == .amd64 { foreign import sqlite "lib/libsqlite3_x64.a" } } else { foreign import sqlite "system:sqlite3" } VERSION :: "3.47.0" VERSION_NUMBER :: 3047000 SOURCE_ID :: "2024-10-21 16:30:22 03a9703e27c44437c39363d0baf82db4ebc94538a0f28411c85dda156f82636e" @(default_calling_convention = "cdecl", link_prefix = "sqlite3_") foreign sqlite { libversion :: proc() -> cstring --- sourceid :: proc() -> cstring --- libversion_number :: proc() -> i32 --- compileoption_used :: proc(option_name: cstring) -> (defined: b32) --- compileoption_get :: proc(n: i32) -> cstring --- threadsafe :: proc() -> (is_thread_safe: b32) --- close :: proc(db: ^sqlite3) -> Result --- close_v2 :: proc(db: ^sqlite3) -> Result --- /* db: An open database sql: SQL to be evaluated cb: Callback function arg: 1st argument to callback err_msg: Error msg written here */ exec :: proc(db: ^sqlite3, sql: cstring, cb: callback, arg: rawptr, err_msg: [^]cstring) -> Result --- initialize :: proc() -> Result --- shutdown :: proc() -> Result --- config :: proc(options: Config, #c_vararg _: ..any) -> Result --- db_config :: proc(db: ^sqlite3, op: i32, #c_vararg options: ..Db_Config) -> Result --- extended_result_codes :: proc(db: ^sqlite3, onoff: b32) -> Result --- last_insert_rowid :: proc(db: ^sqlite3) -> i64 --- set_last_insert_rowid :: proc(db: ^sqlite3, row_id: i64) --- changes :: proc(db: ^sqlite3) -> i32 --- changes64 :: proc(db: ^sqlite3) -> i64 --- total_changes :: proc(db: ^sqlite3) -> i32 --- total_changes64 :: proc(db: ^sqlite3) -> i64 --- interrupt :: proc(db: ^sqlite3) --- interrupted :: proc(db: ^sqlite3) -> (success: b32) --- complete :: proc(sql: cstring) -> (success: b32) --- // omit complete16 :: proc(rawptr sql) --- busy_handler :: proc(db: ^sqlite3, busy: proc(arg: rawptr, proc_event_call_count: i32) -> i32, arg: rawptr) -> Result --- busy_timeout :: proc(db: ^sqlite3, ms: i32) -> Result --- @(deprecated = "This is a legacy interface that is preserved for backwards compatibility. Use of this interface is not recommended.") get_table :: proc(db: ^sqlite3, /* An open database */ sql: cstring, /* SQL to be evaluated */ result: ^[^]cstring, /* Results of the query */ row: ^i32, /* Number of result rows written here */ column: ^i32, /* Number of result columns written here */ err_msg: [^]cstring, /* Error msg written here */) -> Result --- @(deprecated = "This is a legacy interface that is preserved for backwards compatibility. Use of this interface is not recommended.") free_table :: proc(result: [^]cstring) --- // mprintf :: proc(cstring,...) --> cstring --- // vmprintf :: proc(cstring, va_list) --> cstring --- // snprintf :: proc(i32,cstring,cstring, #c_vararg args: ..any) --> cstring --- // vsnprintf :: proc(i32,cstring,cstring, libc.va_list) cstring --- malloc :: proc(_: int) -> rawptr --- malloc64 :: proc(_: u64) -> rawptr --- realloc :: proc(ptr: rawptr, _: int) -> rawptr --- realloc64 :: proc(ptr: rawptr, _: u64) -> rawptr --- free :: proc(ptr: rawptr) --- msize :: proc(ptr: rawptr) -> u64 --- memory_used :: proc() -> i64 --- memory_highwater :: proc(resetFlag: b32) -> i64 --- randomness :: proc(n: i32, buffer: rawptr) --- set_authorizer :: proc(db: ^sqlite3, auth: proc(user_data: rawptr, code: Auth_Action_Code, _: cstring, _: cstring, _: cstring, _: cstring) -> Auth_Return_Code, user_data: rawptr) -> Auth_Return_Code --- trace_v2 :: proc(db: ^sqlite3, mask: Trace_Event_Code, trace: proc(code: Trace_Event_Code, ctx_arg: rawptr, code_p: rawptr, code_x: rawptr) -> i32, ctx_arg: rawptr) --- progress_handler :: proc(db: ^sqlite3, ops: i32, progress: proc(arg: rawptr) -> Result, arg: rawptr) --- /* filename: Database filename (UTF-8) db: SQLite db handle */ open :: proc(filename: cstring, db: ^^sqlite3) -> Result --- // omit open16 :: proc(filename: rawptr, db: ^^sqlite3) -> Result --- /* filename: Database filename (UTF-8) db: SQLite db handle flags: Flags vfs: Name of VFS module to use */ open_v2 :: proc(filename: cstring, db: ^^sqlite3, flags: Open_Flags, vfs: cstring) -> Result --- errcode :: proc(db: ^sqlite3) -> Result --- extended_errcode :: proc(db: ^sqlite3) -> Result --- errmsg :: proc(db: ^sqlite3) -> cstring --- // omit errmsg16 :: proc(db: ^sqlite3) -> rawptr --- errstr :: proc(db: ^sqlite3) -> cstring --- error_offset :: proc(db: ^sqlite3) -> i32 --- limit :: proc(db: ^sqlite3, id: Limit_Category, newVal: i32) -> i32 --- /* db: Database handle sql: SQL statement, UTF-8 encoded nByte: Maximum length of `sql` in bytes. stmt: OUT: Statement handle tail: OUT: Pointer to unused portion of `sql` */ @(deprecated = "'prepare' is deprecated, use 'prepare_v2' instead") prepare :: proc(db: ^sqlite3, sql: cstring, nByte: i32, stmt: ^^stmt, tail: [^]cstring) -> Result --- /* db: Database handle sql: SQL statement, UTF-8 encoded nByte: Maximum length of `sql` in bytes. stmt: OUT: Statement handle tail: OUT: Pointer to unused portion of `sql` */ prepare_v2 :: proc(db: ^sqlite3, sql: cstring, nByte: i32, stmt: ^^stmt, tail: ^cstring) -> Result --- /* db: Database handle sql: SQL statement, UTF-8 encoded nByte: Maximum length of `sql` in bytes. prepFlags: Zero or more Prepare_Flag stmt: OUT: Statement handle tail: OUT: Pointer to unused portion of `sql` */ prepare_v3 :: proc(db: ^sqlite3, sql: cstring, nByte: i32, prepFlags: Prepare_Flag, stmt: ^^stmt, tail: [^]cstring) -> Result --- // omit prepare16(_v(2|3)) sql :: proc(s: ^stmt) -> cstring --- expanded_sql :: proc(s: ^stmt) -> cstring --- //normalized_sql :: proc(s: ^stmt) -> cstring --- stmt_readonly :: proc(s: ^stmt) -> (success: b32) --- /* The stmt_isexplain(S) interface returns 1 if the prepared statement S is an EXPLAIN statement, or 2 if the statement S is an EXPLAIN QUERY PLAN. The stmt_isexplain(S) interface returns 0 if S is an ordinary statement or a NULL pointer. */ stmt_isexplain :: proc(s: ^stmt) -> i32 --- stmt_explain :: proc(s: ^stmt, eMode: i32) -> Result --- stmt_busy :: proc(s: ^stmt) -> (success: b32) --- bind_blob :: proc(s: ^stmt, idx: i32, data: rawptr, n: i32, xDel: proc(ptr: rawptr)) -> Result --- bind_blob64 :: proc(s: ^stmt, idx: i32, data: rawptr, u64, xDel: proc(ptr: rawptr)) -> Result --- bind_double :: proc(s: ^stmt, idx: i32, rValue: f64) -> Result --- bind_int :: proc(s: ^stmt, idx: i32, iValue: i32) -> Result --- bind_int64 :: proc(s: ^stmt, idx: i32, iValue: i64) -> Result --- bind_null :: proc(s: ^stmt, idx: i32) -> Result --- bind_text :: proc(s: ^stmt, idx: i32, data: cstring, n: i32, xDel: proc(ptr: rawptr) = nil) -> Result --- // omit bind_text16 :: proc() bind_text64 :: proc(s: ^stmt, idx: i32, data: cstring, n: u64, xDel: proc(ptr: rawptr) = nil, encoding: Encoding = .UTF8) -> Result --- bind_value :: proc(s: ^stmt, idx: i32, pValue: value) -> Result --- bind_pointer :: proc(s: ^stmt, idx: i32, ptr: rawptr, type: cstring, xDestructor: proc(ptr: rawptr)) -> Result --- bind_zeroblob :: proc(s: ^stmt, idx: i32, n: i32) -> Result --- bind_zeroblob64 :: proc(s: ^stmt, idx: i32, n: u64) -> Result --- bind_parameter_count :: proc(s: ^stmt) -> (count: i32) --- bind_parameter_name :: proc(s: ^stmt, idx: i32) -> (name: cstring) --- bind_parameter_index :: proc(s: ^stmt, name: cstring) -> (idx: i32) --- clear_bindings :: proc(s: ^stmt) -> Result --- column_count :: proc(s: ^stmt) -> (count: i32) --- column_name :: proc(s: ^stmt, column: i32) -> (name: cstring) --- // omit column_name16 column_database_name :: proc(s: ^stmt, column: i32) -> (name: cstring) --- column_table_name :: proc(s: ^stmt, column: i32) -> (name: cstring) --- column_origin_name :: proc(s: ^stmt, column: i32) -> (name: cstring) --- // omit column_database_name16 // omit column_table_name16 // omit column_origin_name16 column_decltype :: proc(s: ^stmt, column: i32) -> (type: cstring) --- // omit column_decltype16 step :: proc(s: ^stmt) -> Result --- data_count :: proc(s: ^stmt) -> (count: i32) --- column_blob :: proc(s: ^stmt, iCol: i32) -> rawptr --- column_double :: proc(s: ^stmt, iCol: i32) -> f64 --- column_int :: proc(s: ^stmt, iCol: i32) -> i32 --- column_int64 :: proc(s: ^stmt, iCol: i32) -> i64 --- column_text :: proc(s: ^stmt, iCol: i32) -> cstring --- // omit column_text16 :: proc(s: ^stmt, iCol: i32) -> rawptr --- column_value :: proc(s: ^stmt, iCol: i32) -> ^value --- column_bytes :: proc(s: ^stmt, iCol: i32) -> i32 --- column_bytes16 :: proc(s: ^stmt, iCol: i32) -> i32 --- column_type :: proc(s: ^stmt, iCol: i32) -> Data_Type --- finalize :: proc(s: ^stmt) -> Result --- reset :: proc(s: ^stmt) -> Result --- create_function :: proc(db: ^sqlite3, function_name: cstring, arg: i32, text_rep: i32, app: rawptr, func: proc(ctx: ^fn_context, val: ^^value), step: proc(ctx: ^fn_context, val: ^^value), final: proc(ctx: ^fn_context)) -> Result --- // omit create_function16 --- create_function_v2 :: proc(db: ^sqlite3, function_name: cstring, arg: i32, text_rep: i32, app: rawptr, func: proc(ctx: ^fn_context, val: ^^value), step: proc(ctx: ^fn_context, val: ^^value), final: proc(ctx: ^fn_context), destroy: proc(app: rawptr)) -> Result --- create_window_function :: proc(db: ^sqlite3, function_name: cstring, arg: i32, text_rep: i32, app: rawptr, step: proc(ctx: ^fn_context, val: ^^value), final: proc(ctx: ^fn_context), value: proc(ctx: ^fn_context), inverse: proc(ctx: ^fn_context, val: ^^value), destroy: proc(app: rawptr)) -> Result --- value_blob :: proc(val: ^value) -> rawptr --- value_double :: proc(val: ^value) -> f64 --- value_int :: proc(val: ^value) -> i32 --- value_int64 :: proc(val: ^value) -> i64 --- value_pointer :: proc(val: ^value, type: cstring) -> rawptr --- value_text :: proc(val: ^value) -> cstring --- // omit value_text16 :: proc(val: ^value) -> rawptr --- // omit value_text16le :: proc(val: ^value) -> rawptr --- // omit value_text16be :: proc(val: ^value) -> rawptr --- value_bytes :: proc(val: ^value) -> i32 --- value_bytes16 :: proc(val: ^value) -> i32 --- value_type :: proc(val: ^value) -> i32 --- value_numeric_type :: proc(val: ^value) -> i32 --- value_nochange :: proc(val: ^value) -> i32 --- value_frombind :: proc(val: ^value) -> i32 --- value_encoding :: proc(val: ^value) -> Encoding --- value_subtype :: proc(val: ^value) -> u32 --- value_dup :: proc(val: ^value) -> ^value --- value_free :: proc(val: ^value) --- aggregate_context :: proc(ctx: ^fn_context, bytes: i32) -> rawptr --- user_data :: proc(ctx: ^fn_context) -> rawptr --- context_db_handle :: proc(ctx: ^fn_context) -> ^fn_context --- get_auxdata :: proc(ctx: ^fn_context, arg: i32) -> rawptr --- set_auxdata :: proc(ctx: ^fn_context, arg: i32, aux: rawptr, delete: proc(aux: rawptr)) --- get_clientdata :: proc(db: ^sqlite3, name: cstring) -> rawptr --- set_clientdata :: proc(db: ^sqlite3, name: cstring, data: rawptr, destructor: proc(_: rawptr)) -> Result --- result_blob :: proc(ctx: ^fn_context, blob: rawptr, n: int, xDel: proc(ptr: rawptr)) --- result_blob64 :: proc(ctx: ^fn_context, blob: rawptr, n: u64, xDel: proc(ptr: rawptr)) --- result_double :: proc(ctx: ^fn_context, val: f64) --- result_error :: proc(ctx: ^fn_context, cstring, n: i32) --- // omit result_error16 :: proc(ctx: ^fn_context, rawptr, int) --- result_error_toobig :: proc(ctx: ^fn_context) --- result_error_nomem :: proc(ctx: ^fn_context) --- result_error_code :: proc(ctx: ^fn_context, error_code: Result) --- result_int :: proc(ctx: ^fn_context, val: int) --- result_int64 :: proc(ctx: ^fn_context, val: i64) --- result_null :: proc(ctx: ^fn_context) --- result_text :: proc(ctx: ^fn_context, val: cstring, n: int, xDel: proc(ptr: rawptr)) --- result_text64 :: proc(ctx: ^fn_context, val: cstring, n: u64, xDel: proc(ptr: rawptr), encoding: Encoding) --- // omit result_text16 :: proc(ctx: ^fn_context, rawptr, int, void(*)(void*)) --- // omit result_text16le :: proc(ctx: ^fn_context, rawptr, int,void(*)(void*)) --- // omit result_text16be :: proc(ctx: ^fn_context, rawptr, int,void(*)(void*)) --- result_value :: proc(ctx: ^fn_context, val: ^value) --- result_pointer :: proc(ctx: ^fn_context, ptr: rawptr, type: cstring, xDestructor: proc(ptr: rawptr)) --- result_zeroblob :: proc(ctx: ^fn_context, n: i32) --- result_zeroblob64 :: proc(ctx: ^fn_context, n: u64) -> i32 --- result_subtype :: proc(ctx: ^fn_context, type: i32) --- create_collation :: proc(db: ^sqlite3, name: cstring, text_rep: i32, arg: rawptr, compare: proc(_: rawptr, _: i32, _: rawptr, _: i32, _: rawptr) -> i32) -> Result --- create_collation_v2 :: proc(db: ^sqlite3, name: cstring, text_rep: i32, arg: rawptr, compare: proc(_: rawptr, _: i32, _: rawptr, _: i32, _: rawptr) -> i32, destroy: proc(_: rawptr)) -> Result --- // omit create_collation16 collation_needed :: proc(db: ^sqlite3, coll_needed_arg: rawptr, coll_needed: proc(_: rawptr, db: ^sqlite3, text_rep: i32, _: cstring)) -> Result --- // omit collation_needed16 sleep :: proc(ms: i32) -> Result --- // --- DO NOT USE --- temp_directory: cstring // --- DO NOT USE --- data_directory: cstring when ODIN_OS == .Windows { win32_set_directory :: proc(type: Win32_Directory_Type, /* Identifier for directory being set or reset */ value: rawptr, /* New value for directory being set or reset */) -> Result --- win32_set_directory8 :: proc(type: Win32_Directory_Type, value: cstring) -> Result --- // omit win32_set_directory16 :: proc(type: i32, value: rawptr) -> Result --- } get_autocommit :: proc(db: ^sqlite3) -> Result --- db_handle :: proc(s: ^stmt) -> ^sqlite3 --- db_name :: proc(db: ^sqlite3, idx: int) -> cstring --- db_filename :: proc(db: ^sqlite3, db_name: cstring) -> cstring --- // 1: read-only, 0: read-write, -1: not a database on connection `db` db_readonly :: proc(db: ^sqlite3, db_name: cstring) -> i32 --- txn_state :: proc(db: ^sqlite3, schema: cstring) -> Txn_State --- next_stmt :: proc(db: ^sqlite3, s: ^stmt) -> ^stmt --- commit_hook :: proc(db: ^sqlite3, callback: proc(_: rawptr) -> Result, arg: rawptr) -> rawptr --- rollback_hook :: proc(db: ^sqlite3, callback: proc(_: rawptr), arg: rawptr) -> rawptr --- autovacuum_pages :: proc(db: ^sqlite3, callback: proc(_: rawptr, _: cstring, _: u32, _: u32, _: u32) -> u32, arg: rawptr, destructor: proc(arg: rawptr)) -> Result --- update_hook :: proc(db: ^sqlite3, callback: proc(_: rawptr, _: i32, _: cstring, _: cstring, _: i64), arg: rawptr) -> rawptr --- enable_shared_cache :: proc(enable: i32) -> (enabled: b32) --- release_memory :: proc(n: i32) -> (freed: i32) --- db_release_memory :: proc(db: ^sqlite3) -> Result --- soft_heap_limit64 :: proc(n: i64) -> i64 --- hard_heap_limit64 :: proc(n: i64) -> i64 --- table_column_metadata :: proc(db: ^sqlite3, /* Connection handle */ db_name: cstring, /* Database name or NULL */ table_name: cstring, /* Table name */ col_name: cstring, /* Column name */ data_type: [^]cstring, /* OUTPUT: Declared data type */ coll_seq: [^]cstring, /* OUTPUT: Collation sequence name */ not_null: ^i32, /* OUTPUT: True if NOT NULL constraint exists */ primary_key: ^i32, /* OUTPUT: True if column part of PK */ auto_inc: ^i32, /* OUTPUT: True if column is auto-increment */) -> Result --- load_extension :: proc(db: ^sqlite3, /* Load the extension into this database connection */ file: cstring, /* Name of the shared library containing extension */ procedure: cstring, /* Entry point. Derived from zFile if 0 */ err_msg: [^]cstring, /* Put error message here if not 0 */) -> Result --- enable_load_extension :: proc(db: ^sqlite3, onoff: b32) -> Result --- // The following two procs oughta be checked again as the entry point's signature is not a true sig auto_extension :: proc(entry_point: proc()) -> Result --- cancel_auto_extension :: proc(entry_point: proc()) -> Result --- reset_auto_extension :: proc() --- create_module :: proc(db: ^sqlite3, /* SQLite connection to register module with */ name: cstring, /* Name of the module */ module: ^module, /* Methods for the module */ client_data: rawptr, /* Client data for xCreate/xConnect */) -> Result --- create_module_v2 :: proc(db: ^sqlite3, /* SQLite connection to register module with */ name: cstring, /* Name of the module */ module: ^module, /* Methods for the module */ client_data: rawptr, /* Client data for xCreate/xConnect */ destroy: proc(_: rawptr), /* Module destructor function */) -> Result --- /* db: Remove modules from this connection */ /* keep: Except, do not remove the ones named here */ drop_modules :: proc(db: ^sqlite3, keep: [^]cstring) -> Result --- declare_vtab :: proc(db: ^sqlite3, sql: cstring) -> Result --- overload_function :: proc(db: ^sqlite3, func_name: cstring, arg: i32) -> Result --- blob_open :: proc(db: ^sqlite3, db_name: cstring, table: cstring, column: cstring, row: i64, flags: b32, blob: ^^blob) -> Result --- blob_reopen :: proc(blob: ^blob, row: i64) -> Result --- blob_close :: proc(blob: ^blob) -> Result --- blob_bytes :: proc(blob: ^blob) -> i32 --- blob_read :: proc(blob: ^blob, buffer: rawptr, n: i32, offset: i32) -> Result --- blob_write :: proc(blob: ^blob, buffer: rawptr, n: i32, offset: i32) -> Result --- vfs_find :: proc(vfs_name: cstring) -> ^vfs --- vfs_register :: proc(vfs: ^vfs, make_default: b32) -> Result --- vfs_unregister :: proc(vfs: ^vfs) -> Result --- // --- MUTEX --- mutex_alloc :: proc(id: Mutex_Type) -> ^mutex --- mutex_free :: proc(mutex: ^mutex) --- mutex_enter :: proc(mutex: ^mutex) --- mutex_try :: proc(mutex: ^mutex) -> Result --- mutex_leave :: proc(mutex: ^mutex) --- db_mutex :: proc(db: ^sqlite3) -> ^mutex --- file_control :: proc(db: ^sqlite3, db_name: cstring, op_code: File_Control_Code, arg: rawptr) --- // omit test_control keyword_count :: proc() -> i32 --- keyword_name :: proc(idx: i32, name: ^cstring, length: ^i32) -> Result --- keyword_check :: proc(name: cstring, length: i32) -> b32 --- // these are unnecessary // str_new :: proc(db: ^sqlite3) -> ^str --- // str_finish:: proc(str: ^str) -> cstring --- // str_appendf:: proc(str: ^str, format: cstring, #c_vararg values: ..any) --- // str_vappendf:: proc(str: ^str, format: cstring, args: libc.va_list) --- // str_append:: proc(str: ^str, in_str: cstring, length: i32) --- // str_appendall:: proc(str: ^str, in_str: cstring) --- // str_appendchar:: proc(str: ^str, char_count: i32, char: u8) --- // str_reset:: proc(str: ^str) --- // str_errcode:: proc(str: ^str) -> Result --- // str_length:: proc(str: ^str) -> i32 --- // str_value:: proc(str: ^str) -> cstring --- status :: proc(op_code: Status_Code, current: ^i32, highwater: ^i32, reset_flag: b32) -> Result --- status64 :: proc(op_code: Status_Code, current: ^i64, highwater: ^i64, resetFlag: b32) -> Result --- db_status :: proc(db: ^sqlite3, op_code: Db_Status_Code, current: ^i32, highwater: ^i32, reset_flag: b32) -> Result --- stmt_status :: proc(s: ^stmt, op_code: Stmt_Status_Code, reset_flag: b32) -> i32 --- // --- BACKUP --- backup_init :: proc(dest_db: ^sqlite3, /* Destination database handle */ dest_name: cstring, /* Destination database name */ src_db: ^sqlite3, /* Source database handle */ src_name: cstring, /* Source database name */) -> ^backup --- backup_step :: proc(backup: ^backup, page: i32) -> Result --- backup_finish :: proc(backup: ^backup) -> Result --- backup_remaining :: proc(backup: ^backup) -> i32 --- backup_pagecount :: proc(backup: ^backup) -> i32 --- unlock_notify :: proc(blocked: ^sqlite3, /* Waiting connection */ notify: proc(arg: [^]rawptr, n: i32), /* Callback function to invoke */ notify_arg: rawptr, /* Argument to pass to xNotify */) -> Result --- // these are unnecessary // stricmp :: proc(_: cstring, _: cstring) -> i32 --- // strnicmp :: proc(_: cstring, _: cstring, i32) -> i32 --- // strglob :: proc(glob: cstring, str: cstring) -> i32 --- // strlike :: proc(glob: cstring, str: cstring, esc: u32) -> i32 --- // log(err_code: i32, format: cstring, #c_vararg args: ..any) --- wal_hook :: proc(db: ^sqlite3, callback: proc(wal_arg: rawptr, db: ^sqlite3, db_name: cstring, pages: i32) -> Result, wal_arg: rawptr) -> rawptr --- wal_autocheckpoint :: proc(db: ^sqlite3, frame: i32) -> Result --- wal_checkpoint :: proc(db: ^sqlite3, db_name: cstring) -> Result --- wal_checkpoint_v2 :: proc(db: ^sqlite3, /* Database handle */ db_name: cstring, /* Name of attached database (or NULL) */ mode: i32, /* SQLITE_CHECKPOINT_* value */ log: ^i32, /* OUT: Size of WAL log in frames */ checkpoint: ^i32, /* OUT: Total number of frames checkpointed */) -> Result --- // --- VTAB --- vtab_config :: proc(db: ^sqlite3, op_code: Vtab_Option, #c_vararg options: ..any) -> i32 --- vtab_on_conflict :: proc(db: ^sqlite3) -> Conflict_Res_Mode --- vtab_nochange :: proc(ctx: ^fn_context) -> b32 --- vtab_collation :: proc(index_info: ^index_info, constraint_idx: i32) -> cstring --- vtab_distinct :: proc(index_info: ^index_info) -> i32 --- vtab_in :: proc(index_info: ^index_info, constraint_idx: i32, handle: b32) -> b32 --- vtab_in_first :: proc(val: ^value, out: ^^value) -> Result --- vtab_in_next :: proc(val: ^value, out: ^^value) -> Result --- vtab_rhs_value :: proc(index_info: ^index_info, constraint_idx: i32, val: ^^value) -> Result --- stmt_scanstatus :: proc(s: ^stmt, /* Prepared statement for which info desired */ idx: i32, /* Index of loop to report on */ op_code: Scan_Status_Code, /* Information desired. SQLITE_SCANSTAT_* */ out: rawptr, /* Result written here */) -> Result --- stmt_scanstatus_v2 :: proc(s: ^stmt, /* Prepared statement for which info desired */ idx: i32, /* Index of loop to report on */ op_code: Scan_Status_Code, /* Information desired. SQLITE_SCANSTAT_* */ flags: Scan_Status_Flag, /* Mask of flags defined below */ out: rawptr, /* Result written here */) -> Result --- stmt_scanstatus_reset :: proc(s: ^stmt) --- db_cacheflush :: proc(db: ^sqlite3) -> Result --- system_errno :: proc(db: ^sqlite3) -> Result --- serialize :: proc(db: ^sqlite3, /* The database connection */ schema: cstring, /* Which DB to serialize. ex: "main", "temp", ... */ size: ^i64, /* Write size of the DB here, if not NULL */ flags: Serialize_Flag, /* Zero or more SQLITE_SERIALIZE_* flags */) -> cstring --- deserialize :: proc(db: ^sqlite3, /* The database connection */ schema: cstring, /* Which DB to reopen with the deserialization */ data: cstring, /* The serialized database content */ byte_count: i64, /* Number bytes in the deserialization */ buffer_size: i64, /* Total size of buffer pData[] */ flags: Deserialize_Flag, /* Zero or more SQLITE_DESERIALIZE_* flags */) -> Result --- } Result :: enum i32 { OK = 0, /* Successful result */ ERROR = 1, /* Generic error */ INTERNAL = 2, /* Internal logic error in SQLite */ PERM = 3, /* Access permission denied */ ABORT = 4, /* Callback routine requested an abort */ BUSY = 5, /* The database file is locked */ LOCKED = 6, /* A table in the database is locked */ NOMEM = 7, /* A malloc() failed */ READONLY = 8, /* Attempt to write a readonly database */ INTERRUPT = 9, /* Operation terminated by interrupt()*/ IOERR = 10, /* Some kind of disk I/O error occurred */ CORRUPT = 11, /* The database disk image is malformed */ NOTFOUND = 12, /* Unknown opcode in file_control() */ FULL = 13, /* Insertion failed because database is full */ CANTOPEN = 14, /* Unable to open the database file */ PROTOCOL = 15, /* Database lock protocol error */ EMPTY = 16, /* Internal use only */ SCHEMA = 17, /* The database schema changed */ TOOBIG = 18, /* String or BLOB exceeds size limit */ CONSTRAINT = 19, /* Abort due to constraint violation */ MISMATCH = 20, /* Data type mismatch */ MISUSE = 21, /* Library used incorrectly */ NOLFS = 22, /* Uses OS features not supported on host */ AUTH = 23, /* Authorization denied */ FORMAT = 24, /* Not used */ RANGE = 25, /* 2nd parameter to bind out of range */ NOTADB = 26, /* File opened that is not a database file */ NOTICE = 27, /* Notifications from log() */ WARNING = 28, /* Warnings from log() */ ROW = 100, /* step() has another row ready */ DONE = 101, /* step() has finished executing */ // Extended Error Codes ERROR_MISSING_COLLSEQ = (ERROR | (1 << 8)), ERROR_RETRY = (ERROR | (2 << 8)), ERROR_SNAPSHOT = (ERROR | (3 << 8)), IOERR_READ = (IOERR | (1 << 8)), IOERR_SHORT_READ = (IOERR | (2 << 8)), IOERR_WRITE = (IOERR | (3 << 8)), IOERR_FSYNC = (IOERR | (4 << 8)), IOERR_DIR_FSYNC = (IOERR | (5 << 8)), IOERR_TRUNCATE = (IOERR | (6 << 8)), IOERR_FSTAT = (IOERR | (7 << 8)), IOERR_UNLOCK = (IOERR | (8 << 8)), IOERR_RDLOCK = (IOERR | (9 << 8)), IOERR_DELETE = (IOERR | (10 << 8)), IOERR_BLOCKED = (IOERR | (11 << 8)), IOERR_NOMEM = (IOERR | (12 << 8)), IOERR_ACCESS = (IOERR | (13 << 8)), IOERR_CHECKRESERVEDLOCK = (IOERR | (14 << 8)), IOERR_LOCK = (IOERR | (15 << 8)), IOERR_CLOSE = (IOERR | (16 << 8)), IOERR_DIR_CLOSE = (IOERR | (17 << 8)), IOERR_SHMOPEN = (IOERR | (18 << 8)), IOERR_SHMSIZE = (IOERR | (19 << 8)), IOERR_SHMLOCK = (IOERR | (20 << 8)), IOERR_SHMMAP = (IOERR | (21 << 8)), IOERR_SEEK = (IOERR | (22 << 8)), IOERR_DELETE_NOENT = (IOERR | (23 << 8)), IOERR_MMAP = (IOERR | (24 << 8)), IOERR_GETTEMPPATH = (IOERR | (25 << 8)), IOERR_CONVPATH = (IOERR | (26 << 8)), IOERR_VNODE = (IOERR | (27 << 8)), IOERR_AUTH = (IOERR | (28 << 8)), IOERR_BEGIN_ATOMIC = (IOERR | (29 << 8)), IOERR_COMMIT_ATOMIC = (IOERR | (30 << 8)), IOERR_ROLLBACK_ATOMIC = (IOERR | (31 << 8)), IOERR_DATA = (IOERR | (32 << 8)), IOERR_CORRUPTFS = (IOERR | (33 << 8)), IOERR_IN_PAGE = (IOERR | (34 << 8)), LOCKED_SHAREDCACHE = (LOCKED | (1 << 8)), LOCKED_VTAB = (LOCKED | (2 << 8)), BUSY_RECOVERY = (BUSY | (1 << 8)), BUSY_SNAPSHOT = (BUSY | (2 << 8)), BUSY_TIMEOUT = (BUSY | (3 << 8)), CANTOPEN_NOTEMPDIR = (CANTOPEN | (1 << 8)), CANTOPEN_ISDIR = (CANTOPEN | (2 << 8)), CANTOPEN_FULLPATH = (CANTOPEN | (3 << 8)), CANTOPEN_CONVPATH = (CANTOPEN | (4 << 8)), CANTOPEN_DIRTYWAL = (CANTOPEN | (5 << 8)), /* Not Used */ CANTOPEN_SYMLINK = (CANTOPEN | (6 << 8)), CORRUPT_VTAB = (CORRUPT | (1 << 8)), CORRUPT_SEQUENCE = (CORRUPT | (2 << 8)), CORRUPT_INDEX = (CORRUPT | (3 << 8)), READONLY_RECOVERY = (READONLY | (1 << 8)), READONLY_CANTLOCK = (READONLY | (2 << 8)), READONLY_ROLLBACK = (READONLY | (3 << 8)), READONLY_DBMOVED = (READONLY | (4 << 8)), READONLY_CANTINIT = (READONLY | (5 << 8)), READONLY_DIRECTORY = (READONLY | (6 << 8)), ABORT_ROLLBACK = (ABORT | (2 << 8)), CONSTRAINT_CHECK = (CONSTRAINT | (1 << 8)), CONSTRAINT_COMMITHOOK = (CONSTRAINT | (2 << 8)), CONSTRAINT_FOREIGNKEY = (CONSTRAINT | (3 << 8)), CONSTRAINT_FUNCTION = (CONSTRAINT | (4 << 8)), CONSTRAINT_NOTNULL = (CONSTRAINT | (5 << 8)), CONSTRAINT_PRIMARYKEY = (CONSTRAINT | (6 << 8)), CONSTRAINT_TRIGGER = (CONSTRAINT | (7 << 8)), CONSTRAINT_UNIQUE = (CONSTRAINT | (8 << 8)), CONSTRAINT_VTAB = (CONSTRAINT | (9 << 8)), CONSTRAINT_ROWID = (CONSTRAINT | (10 << 8)), CONSTRAINT_PINNED = (CONSTRAINT | (11 << 8)), CONSTRAINT_DATATYPE = (CONSTRAINT | (12 << 8)), NOTICE_RECOVER_WAL = (NOTICE | (1 << 8)), NOTICE_RECOVER_ROLLBACK = (NOTICE | (2 << 8)), NOTICE_RBU = (NOTICE | (3 << 8)), WARNING_AUTOINDEX = (WARNING | (1 << 8)), AUTH_USER = (AUTH | (1 << 8)), OK_LOAD_PERMANENTLY = (OK | (1 << 8)), OK_SYMLINK = (OK | (2 << 8)), /* internal use only */ } Open_Flags :: enum i32 { READONLY = 0x00000001, /* Ok for open_v2() */ READWRITE = 0x00000002, /* Ok for open_v2() */ CREATE = 0x00000004, /* Ok for open_v2() */ DELETEONCLOSE = 0x00000008, /* VFS only */ EXCLUSIVE = 0x00000010, /* VFS only */ AUTOPROXY = 0x00000020, /* VFS only */ URI = 0x00000040, /* Ok for open_v2() */ MEMORY = 0x00000080, /* Ok for open_v2() */ MAIN_DB = 0x00000100, /* VFS only */ TEMP_DB = 0x00000200, /* VFS only */ TRANSIENT_DB = 0x00000400, /* VFS only */ MAIN_JOURNAL = 0x00000800, /* VFS only */ TEMP_JOURNAL = 0x00001000, /* VFS only */ SUBJOURNAL = 0x00002000, /* VFS only */ SUPER_JOURNAL = 0x00004000, /* VFS only */ NOMUTEX = 0x00008000, /* Ok for open_v2() */ FULLMUTEX = 0x00010000, /* Ok for open_v2() */ SHAREDCACHE = 0x00020000, /* Ok for open_v2() */ PRIVATECACHE = 0x00040000, /* Ok for open_v2() */ WAL = 0x00080000, /* VFS only */ NOFOLLOW = 0x01000000, /* Ok for open_v2() */ EXRESCODE = 0x02000000, /* Extended result codes */ /* Reserved: 0x00F00000 */ /* Legacy compatibility: */ MASTER_JOURNAL = 0x00004000, /* VFS only */ } Io_Cap :: enum u16 { ATOMIC = 0x00000001, ATOMIC512 = 0x00000002, ATOMIC1K = 0x00000004, ATOMIC2K = 0x00000008, ATOMIC4K = 0x00000010, ATOMIC8K = 0x00000020, ATOMIC16K = 0x00000040, ATOMIC32K = 0x00000080, ATOMIC64K = 0x00000100, SAFE_APPEND = 0x00000200, SEQUENTIAL = 0x00000400, UNDELETABLE_WHEN_OPEN = 0x00000800, POWERSAFE_OVERWRITE = 0x00001000, IMMUTABLE = 0x00002000, BATCH_ATOMIC = 0x00004000, } File_Lock :: enum u8 { NONE = 0, /* xUnlock() only */ SHARED = 1, /* xLock() or xUnlock() */ RESERVED = 2, /* xLock() only */ PENDING = 3, /* xLock() only */ EXCLUSIVE = 4, /* xLock() only */ } Sync_Type :: enum u8 { NORMAL = 0x00002, FULL = 0x00003, DATAONLY = 0x00010, } Config :: enum i32 { SINGLETHREAD = 1, /* nil */ MULTITHREAD = 2, /* nil */ SERIALIZED = 3, /* nil */ MALLOC = 4, /* mem_methods* */ GETMALLOC = 5, /* mem_methods* */ SCRATCH = 6, /* No longer used */ PAGECACHE = 7, /* void*, int sz, int N */ HEAP = 8, /* void*, int nByte, int min */ MEMSTATUS = 9, /* boolean */ MUTEX = 10, /* mutex_methods* */ GETMUTEX = 11, /* mutex_methods* */ LOOKASIDE = 13, /* int int */ PCACHE = 14, /* no-op */ GETPCACHE = 15, /* no-op */ LOG = 16, /* xFunc, void* */ URI = 17, /* int */ PCACHE2 = 18, /* pcache_methods2* */ GETPCACHE2 = 19, /* pcache_methods2* */ COVERING_INDEX_SCAN = 20, /* int */ SQLLOG = 21, /* xSqllog, void* */ MMAP_SIZE = 22, /* int64, int64 */ WIN32_HEAPSIZE = 23, /* int nByte */ PCACHE_HDRSZ = 24, /* int *psz */ PMASZ = 25, /* unsigned int szPma */ STMTJRNL_SPILL = 26, /* int nByte */ SMALL_MALLOC = 27, /* boolean */ SORTERREF_SIZE = 28, /* int nByte */ MEMDB_MAXSIZE = 29, /* int64 */ ROWID_IN_VIEW = 30, /* int* */ } Db_Config :: enum i32 { MAINDBNAME = 1000, /* const char* */ LOOKASIDE = 1001, /* void* int int */ ENABLE_FKEY = 1002, /* int int* */ ENABLE_TRIGGER = 1003, /* int int* */ ENABLE_FTS3_TOKENIZER = 1004, /* int int* */ ENABLE_LOAD_EXTENSION = 1005, /* int int* */ NO_CKPT_ON_CLOSE = 1006, /* int int* */ ENABLE_QPSG = 1007, /* int int* */ TRIGGER_EQP = 1008, /* int int* */ RESET_DATABASE = 1009, /* int int* */ DEFENSIVE = 1010, /* int int* */ WRITABLE_SCHEMA = 1011, /* int int* */ LEGACY_ALTER_TABLE = 1012, /* int int* */ DQS_DML = 1013, /* int int* */ DQS_DDL = 1014, /* int int* */ ENABLE_VIEW = 1015, /* int int* */ LEGACY_FILE_FORMAT = 1016, /* int int* */ TRUSTED_SCHEMA = 1017, /* int int* */ STMT_SCANSTATUS = 1018, /* int int* */ REVERSE_SCANORDER = 1019, /* int int* */ } Trace :: enum i32 { STMT = 0x01, PROFILE = 0x02, ROW = 0x04, CLOSE = 0x08, } Limit_Category :: enum i32 { LENGTH = 0, SQL_LENGTH = 1, COLUMN = 2, EXPR_DEPTH = 3, COMPOUND_SELECT = 4, VDBE_OP = 5, FUNCTION_ARG = 6, ATTACHED = 7, LIKE_PATTERN_LENGTH = 8, VARIABLE_NUMBER = 9, TRIGGER_DEPTH = 10, WORKER_THREADS = 11, } // LIMIT_LENGTH :: Limit_Category.LENGTH // LIMIT_SQL_LENGTH :: Limit_Category.SQL_LENGTH // LIMIT_COLUMN :: Limit_Category.COLUMN // LIMIT_EXPR_DEPTH :: Limit_Category.EXPR_DEPTH // LIMIT_COMPOUND_SELECT :: Limit_Category.COMPOUND_SELECT // LIMIT_VDBE_OP :: Limit_Category.VDBE_OP // LIMIT_FUNCTION_ARG :: Limit_Category.FUNCTION_ARG // LIMIT_ATTACHED :: Limit_Category.ATTACHED // LIMIT_LIKE_PATTERN_LENGTH :: Limit_Category.LIKE_PATTERN_LENGTH // LIMIT_VARIABLE_NUMBER :: Limit_Category.VARIABLE_NUMBER // LIMIT_TRIGGER_DEPTH :: Limit_Category.TRIGGER_DEPTH // LIMIT_WORKER_THREADS :: Limit_Category.WORKER_THREADS // N_LIMIT :: len(Limit_Category) + 1 Prepare_Flag :: enum i32 { PERSISTENT = 0x01, NORMALIZE = 0x02, NO_VTAB = 0x04, } Data_Type :: enum i32 { INTEGER = 1, FLOAT = 2, TEXT = 3, BLOB = 4, NULL = 5, } Encoding :: enum u8 { UTF8 = 1, /* IMP: R-37514-35566 */ UTF16LE = 2, /* IMP: R-03371-37637 */ UTF16BE = 3, /* IMP: R-51971-34154 */ UTF16 = 4, /* Use native byte order */ ANY = 5, /* Deprecated */ UTF16_ALIGNED = 8, /* create_collation only */ } Function_Flag :: enum i32 { DETERMINISTIC = 0x000000800, DIRECTONLY = 0x000080000, SUBTYPE = 0x000100000, INNOCUOUS = 0x000200000, RESULT_SUBTYPE = 0x001000000, SELFORDER1 = 0x002000000, } Txn_State :: enum i32 { NONE = 0, READ = 1, WRITE = 2, } Mutex_Type :: enum i32 { FAST = 0, RECURSIVE = 1, STATIC_MAIN = 2, STATIC_MEM = 3, /* malloc() */ STATIC_MEM2 = 4, /* NOT USED */ STATIC_OPEN = 4, /* sqlite3BtreeOpen() */ STATIC_PRNG = 5, /* randomness() */ STATIC_LRU = 6, /* lru page list */ STATIC_LRU2 = 7, /* NOT USED */ STATIC_PMEM = 7, /* sqlite3PageMalloc() */ STATIC_APP1 = 8, /* For use by application */ STATIC_APP2 = 9, /* For use by application */ STATIC_APP3 = 10, /* For use by application */ STATIC_VFS1 = 11, /* For use by built-in VFS */ STATIC_VFS2 = 12, /* For use by extension VFS */ STATIC_VFS3 = 13, /* For use by application VFS */ /* Legacy compatibility: */ STATIC_MASTER = 2, } Status_Code :: enum i32 { MEMORY_USED = 0, PAGECACHE_USED = 1, PAGECACHE_OVERFLOW = 2, SCRATCH_USED = 3, /* NOT USED */ SCRATCH_OVERFLOW = 4, /* NOT USED */ MALLOC_SIZE = 5, PARSER_STACK = 6, PAGECACHE_SIZE = 7, SCRATCH_SIZE = 8, /* NOT USED */ MALLOC_COUNT = 9, } Db_Status_Code :: enum i32 { LOOKASIDE_USED = 0, CACHE_USED = 1, SCHEMA_USED = 2, STMT_USED = 3, LOOKASIDE_HIT = 4, LOOKASIDE_MISS_SIZE = 5, LOOKASIDE_MISS_FULL = 6, CACHE_HIT = 7, CACHE_MISS = 8, CACHE_WRITE = 9, DEFERRED_FKS = 10, CACHE_USED_SHARED = 11, CACHE_SPILL = 12, } Stmt_Status_Code :: enum i32 { FULLSCAN_STEP = 1, SORT = 2, AUTOINDEX = 3, VM_STEP = 4, REPREPARE = 5, RUN = 6, FILTER_MISS = 7, FILTER_HIT = 8, MEMUSED = 99, } Checkpoint_Mode :: enum i32 { PASSIVE = 0, /* Do as much as possible w/o blocking */ FULL = 1, /* Wait for writers, then checkpoint */ RESTART = 2, /* Like FULL but wait for readers */ TRUNCATE = 3, /* Like RESTART but also truncate WAL */ } Vtab_Option :: enum i32 { CONSTRAINT_SUPPORT = 1, INNOCUOUS = 2, DIRECTONLY = 3, USES_ALL_SCHEMAS = 4, } Conflict_Res_Mode :: enum i32 { ROLLBACK = 1, IGNORE = 2, FAIL = 3, ABORT = 4, REPLACE = 5, } Scan_Status_Code :: enum i32 { // --- Op Codes --- NLOOP = 0, NVISIT = 1, EST = 2, NAME = 3, EXPLAIN = 4, SELECTID = 5, PARENTID = 6, NCYCLE = 7, } Scan_Status_Flag :: enum i32 { NONE = 0x0000, COMPLEX = 0x0001, } Serialize_Flag :: enum i32 { NONE = 0x000, NOCOPY = 0x001, /* Do no memory allocations */ } Deserialize_Flag :: enum i32 { NONE = 0, FREEONCLOSE = 1, /* Call sqlite3.free() on close */ RESIZEABLE = 2, /* Resize using sqlite3.realloc64() */ READONLY = 4, /* Database is read-only */ } File_Control_Code :: enum { LOCKSTATE = 1, GET_LOCKPROXYFILE = 2, SET_LOCKPROXYFILE = 3, LAST_ERRNO = 4, SIZE_HINT = 5, CHUNK_SIZE = 6, FILE_POINTER = 7, SYNC_OMITTED = 8, WIN32_AV_RETRY = 9, PERSIST_WAL = 10, OVERWRITE = 11, VFSNAME = 12, POWERSAFE_OVERWRITE = 13, PRAGMA = 14, BUSYHANDLER = 15, TEMPFILENAME = 16, MMAP_SIZE = 18, TRACE = 19, HAS_MOVED = 20, SYNC = 21, COMMIT_PHASETWO = 22, WIN32_SET_HANDLE = 23, WAL_BLOCK = 24, ZIPVFS = 25, RBU = 26, VFS_POINTER = 27, JOURNAL_POINTER = 28, WIN32_GET_HANDLE = 29, PDB = 30, BEGIN_ATOMIC_WRITE = 31, COMMIT_ATOMIC_WRITE = 32, ROLLBACK_ATOMIC_WRITE = 33, LOCK_TIMEOUT = 34, DATA_VERSION = 35, SIZE_LIMIT = 36, CKPT_DONE = 37, RESERVE_BYTES = 38, CKPT_START = 39, EXTERNAL_READER = 40, CKSM_FILE = 41, RESET_CACHE = 42, } Auth_Action_Code :: enum i32 { CREATE_INDEX = 1, /* Index Name Table Name */ CREATE_TABLE = 2, /* Table Name NULL */ CREATE_TEMP_INDEX = 3, /* Index Name Table Name */ CREATE_TEMP_TABLE = 4, /* Table Name NULL */ CREATE_TEMP_TRIGGER = 5, /* Trigger Name Table Name */ CREATE_TEMP_VIEW = 6, /* View Name NULL */ CREATE_TRIGGER = 7, /* Trigger Name Table Name */ CREATE_VIEW = 8, /* View Name NULL */ DELETE = 9, /* Table Name NULL */ DROP_INDEX = 10, /* Index Name Table Name */ DROP_TABLE = 11, /* Table Name NULL */ DROP_TEMP_INDEX = 12, /* Index Name Table Name */ DROP_TEMP_TABLE = 13, /* Table Name NULL */ DROP_TEMP_TRIGGER = 14, /* Trigger Name Table Name */ DROP_TEMP_VIEW = 15, /* View Name NULL */ DROP_TRIGGER = 16, /* Trigger Name Table Name */ DROP_VIEW = 17, /* View Name NULL */ INSERT = 18, /* Table Name NULL */ PRAGMA = 19, /* Pragma Name 1st arg or NULL */ READ = 20, /* Table Name Column Name */ SELECT = 21, /* NULL NULL */ TRANSACTION = 22, /* Operation NULL */ UPDATE = 23, /* Table Name Column Name */ ATTACH = 24, /* Filename NULL */ DETACH = 25, /* Database Name NULL */ ALTER_TABLE = 26, /* Database Name Table Name */ REINDEX = 27, /* Index Name NULL */ ANALYZE = 28, /* Table Name NULL */ CREATE_VTABLE = 29, /* Table Name Module Name */ DROP_VTABLE = 30, /* Table Name Module Name */ FUNCTION = 31, /* NULL Function Name */ SAVEPOINT = 32, /* Operation Savepoint Name */ COPY = 0, /* No longer used */ RECURSIVE = 33, /* NULL NULL */ } Auth_Return_Code :: enum i32 { OK = 0, DENY = 1, IGNORE = 2, } Trace_Event_Code :: enum u32 { DISABLE = 0x00, STMT = 0x01, PROFILE = 0x02, ROW = 0x04, CLOSE = 0x08, } sqlite3 :: struct {} stmt :: struct {} fn_context :: struct {} // context is keyword module :: struct {} blob :: struct {} vfs :: struct {} mutex :: struct {} // str :: struct {} backup :: struct {} index_info :: struct {} callback :: proc "c" (db: rawptr, col: i32, vals: [^]cstring, cols: [^]cstring) -> Result value :: struct { u: struct #raw_union {}, // MemValue z: cstring, /* String or BLOB value */ n: i32, /* Number of characters in string value, excluding '\0' */ flags: u16, /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ encoding: u8, /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */ sub_type: u8, /* Subtype for this value */ } mem_methods :: struct { malloc: proc "c" (n: i32) -> rawptr, /* Memory allocation function */ free: proc "c" (ptr: rawptr), /* Free a prior allocation */ realloc: proc "c" (ptr: rawptr, n: i32) -> rawptr, /* Resize an allocation */ size: proc "c" (ptr: rawptr) -> i32, /* Return the size of an allocation */ roundup: proc "c" (n: i32) -> i32, /* Round up request size to allocation size */ init: proc "c" (appData: rawptr) -> i32, /* Initialize the memory allocator */ shutdown: proc "c" (appData: rawptr), /* Deinitialize the memory allocator */ appData: rawptr, /* Argument to init() and shutdown() */ } when ODIN_OS == .Windows { Win32_Directory_Type :: enum i32 { DATA = 1, TEMP = 2, } }