Struct LibSqlite3 

pub struct LibSqlite3 { /* private fields */ }

Dynamic libsqlite3 backend adapter loaded via dlopen.

Implementations

impl LibSqlite3

pub fn load() -> Option<&'static LibSqlite3>

Load libsqlite3 and return a process-wide adapter instance.

Returns None if the library or required symbols are unavailable.

pub unsafe fn abi_db_filename( &self, db: *mut c_void, name: Option<&str>, ) -> Option<RawBytes>

ABI helper: sqlite3_db_filename.

The returned bytes are backend-managed and follow SQLite pointer lifetime rules.

Safety

db must be a valid sqlite3* from this loaded backend, and must remain valid for the duration of the call.

pub unsafe fn abi_get_autocommit(&self, db: *mut c_void) -> i32

ABI helper: sqlite3_get_autocommit.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_total_changes(&self, db: *mut c_void) -> i32

ABI helper: sqlite3_total_changes.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_changes(&self, db: *mut c_void) -> i32

ABI helper: sqlite3_changes.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_changes64(&self, db: *mut c_void) -> i64

ABI helper: sqlite3_changes64.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_last_insert_rowid(&self, db: *mut c_void) -> i64

ABI helper: sqlite3_last_insert_rowid.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_interrupt(&self, db: *mut c_void)

ABI helper: sqlite3_interrupt.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_db_config(&self, db: *mut c_void, op: i32) -> i32

ABI helper: sqlite3_db_config.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_limit(&self, db: *mut c_void, id: i32, new_value: i32) -> i32

ABI helper: sqlite3_limit.

Safety

db must be a valid sqlite3* from this loaded backend.

pub unsafe fn abi_stmt_readonly(&self, stmt: *mut c_void) -> i32

ABI helper: sqlite3_stmt_readonly.

Safety

stmt must be a valid sqlite3_stmt* from this loaded backend.

pub unsafe fn abi_stmt_busy(&self, stmt: *mut c_void) -> i32

ABI helper: sqlite3_stmt_busy.

Safety

stmt must be a valid sqlite3_stmt* from this loaded backend.

pub unsafe fn abi_bind_parameter_count(&self, stmt: *mut c_void) -> i32

ABI helper: sqlite3_bind_parameter_count.

Safety

stmt must be a valid sqlite3_stmt* from this loaded backend.

pub unsafe fn abi_bind_parameter_name( &self, stmt: *mut c_void, idx: i32, ) -> Option<RawBytes>

ABI helper: sqlite3_bind_parameter_name.

The returned bytes are backend-managed and follow SQLite pointer lifetime rules.

Safety

stmt must be a valid sqlite3_stmt* from this loaded backend.

pub unsafe fn abi_bind_parameter_index( &self, stmt: *mut c_void, name: &str, ) -> i32

ABI helper: sqlite3_bind_parameter_index.

Safety

stmt must be a valid sqlite3_stmt* from this loaded backend.

pub unsafe fn abi_context_db_handle( &self, ctx: *mut c_void, ) -> Option<NonNull<c_void>>

ABI helper: sqlite3_context_db_handle.

Safety

ctx must be a valid sqlite3_context* provided by SQLite for an active scalar/aggregate/window callback.

Trait Implementations

impl Sqlite3Api for LibSqlite3

type Db = c_void

Backend’s opaque sqlite3* type.

type Stmt = c_void

Backend’s opaque sqlite3_stmt* type.

type Value = c_void

Backend’s opaque sqlite3_value* type.

type Context = c_void

Backend’s opaque sqlite3_context* type.

type VTab = c_void

Backend’s opaque sqlite3_vtab* type.

type VTabCursor = c_void

Backend’s opaque sqlite3_vtab_cursor* type.

fn api_version(&self) -> ApiVersion

Declared SQLite API version supported by this provider implementation.

fn feature_set(&self) -> FeatureSet

Compile/runtime capability flags available through this provider.

fn backend_name(&self) -> &'static str

Stable backend identifier (for diagnostics and capability routing).

fn backend_version(&self) -> Option<ApiVersion>

Optional backend runtime version (if queryable).

unsafe fn malloc(&self, size: usize) -> *mut c_void

Return SQLite allocator-compatible memory for cross-FFI ownership.

unsafe fn free(&self, ptr: *mut c_void)

Free memory allocated through malloc.

fn threadsafe(&self) -> i32

Thread-safety capability in sqlite3_threadsafe() form.

unsafe fn open( &self, filename: &str, options: OpenOptions<'_>, ) -> Result<NonNull<Self::Db>>

Open a database connection using backend-specific open_v2 semantics.

unsafe fn close(&self, db: NonNull<Self::Db>) -> Result<()>

Close a database connection handle.

unsafe fn prepare_v2( &self, db: NonNull<Self::Db>, sql: &str, ) -> Result<NonNull<Self::Stmt>>

Prepare SQL using legacy prepare_v2 behavior.

unsafe fn prepare_v3( &self, db: NonNull<Self::Db>, sql: &str, flags: u32, ) -> Result<NonNull<Self::Stmt>>

Prepare SQL with prepare_v3 flags.

unsafe fn step(&self, stmt: NonNull<Self::Stmt>) -> Result<StepResult>

Execute one step of the virtual machine.

unsafe fn reset(&self, stmt: NonNull<Self::Stmt>) -> Result<()>

Reset a prepared statement to run again.

unsafe fn finalize(&self, stmt: NonNull<Self::Stmt>) -> Result<()>

Finalize a prepared statement and release backend resources.

unsafe fn bind_null(&self, stmt: NonNull<Self::Stmt>, idx: i32) -> Result<()>

Bind SQL NULL at parameter index idx (1-based).

unsafe fn bind_int64( &self, stmt: NonNull<Self::Stmt>, idx: i32, v: i64, ) -> Result<()>

Bind 64-bit integer at parameter index idx (1-based).

unsafe fn bind_double( &self, stmt: NonNull<Self::Stmt>, idx: i32, v: f64, ) -> Result<()>

Bind floating value at parameter index idx (1-based).

unsafe fn bind_text( &self, stmt: NonNull<Self::Stmt>, idx: i32, v: &str, ) -> Result<()>

Bind UTF-8 text at parameter index idx (1-based).

unsafe fn bind_text_bytes( &self, stmt: NonNull<Self::Stmt>, idx: i32, v: &[u8], ) -> Result<()>

Bind text bytes at parameter index idx (1-based).

unsafe fn bind_blob( &self, stmt: NonNull<Self::Stmt>, idx: i32, v: &[u8], ) -> Result<()>

Bind bytes at parameter index idx (1-based).

unsafe fn column_count(&self, stmt: NonNull<Self::Stmt>) -> i32

Number of columns in the current result row.

unsafe fn column_type(&self, stmt: NonNull<Self::Stmt>, col: i32) -> ValueType

SQLite storage class for col in the current row.

unsafe fn column_int64(&self, stmt: NonNull<Self::Stmt>, col: i32) -> i64

Integer value for col in the current row.

unsafe fn column_double(&self, stmt: NonNull<Self::Stmt>, col: i32) -> f64

Floating value for col in the current row.

unsafe fn column_text(&self, stmt: NonNull<Self::Stmt>, col: i32) -> RawBytes

Raw text bytes for col in the current row snapshot.

unsafe fn column_blob(&self, stmt: NonNull<Self::Stmt>, col: i32) -> RawBytes

Raw blob bytes for col in the current row snapshot.

unsafe fn errcode(&self, db: NonNull<Self::Db>) -> i32

Primary SQLite result code for a connection.

unsafe fn errmsg(&self, db: NonNull<Self::Db>) -> *const c_char

Backend-provided UTF-8 error message pointer for a connection.

unsafe fn extended_errcode(&self, db: NonNull<Self::Db>) -> Option<i32>

Extended SQLite result code, if supported.

unsafe fn create_function_v2( &self, db: NonNull<Self::Db>, name: &str, n_args: i32, flags: FunctionFlags, x_func: Option<extern "C" fn(*mut Self::Context, i32, *mut *mut Self::Value)>, x_step: Option<extern "C" fn(*mut Self::Context, i32, *mut *mut Self::Value)>, x_final: Option<extern "C" fn(*mut Self::Context)>, user_data: *mut c_void, drop_user_data: Option<extern "C" fn(*mut c_void)>, ) -> Result<()>

Register scalar/aggregate callbacks.

unsafe fn create_window_function( &self, db: NonNull<Self::Db>, name: &str, n_args: i32, flags: FunctionFlags, x_step: Option<extern "C" fn(*mut Self::Context, i32, *mut *mut Self::Value)>, x_final: Option<extern "C" fn(*mut Self::Context)>, x_value: Option<extern "C" fn(*mut Self::Context)>, x_inverse: Option<extern "C" fn(*mut Self::Context, i32, *mut *mut Self::Value)>, user_data: *mut c_void, drop_user_data: Option<extern "C" fn(*mut c_void)>, ) -> Result<()>

Register window-function callbacks.

unsafe fn create_collation_v2( &self, db: NonNull<Self::Db>, name: &str, enc: i32, context: *mut c_void, cmp: Option<extern "C" fn(*mut c_void, i32, *const c_void, i32, *const c_void) -> i32>, destroy: Option<extern "C" fn(*mut c_void)>, ) -> Result<()>

Register or replace a collation sequence.

unsafe fn aggregate_context( &self, ctx: NonNull<Self::Context>, bytes: usize, ) -> *mut c_void

Fetch or allocate aggregate state memory for ctx.

unsafe fn result_null(&self, ctx: NonNull<Self::Context>)

Set current function result to NULL.

unsafe fn result_int64(&self, ctx: NonNull<Self::Context>, v: i64)

Set current function result to integer.

unsafe fn result_double(&self, ctx: NonNull<Self::Context>, v: f64)

Set current function result to floating value.

unsafe fn result_text(&self, ctx: NonNull<Self::Context>, v: &str)

Providers must ensure SQLite copies or retains the buffer for v.

unsafe fn result_text_bytes(&self, ctx: NonNull<Self::Context>, v: &[u8])

Providers must ensure SQLite copies or retains the buffer for v.

unsafe fn result_blob(&self, ctx: NonNull<Self::Context>, v: &[u8])

Providers must ensure SQLite copies or retains the buffer for v.

unsafe fn result_error(&self, ctx: NonNull<Self::Context>, msg: &str)

Set current function result to an error message.

unsafe fn user_data(ctx: NonNull<Self::Context>) -> *mut c_void

Return function user_data for ctx.

unsafe fn value_type(&self, v: NonNull<Self::Value>) -> ValueType

SQLite storage class of a UDF argument value.

unsafe fn value_int64(&self, v: NonNull<Self::Value>) -> i64

Integer view of a UDF argument value.

unsafe fn value_double(&self, v: NonNull<Self::Value>) -> f64

Floating view of a UDF argument value.

unsafe fn value_text(&self, v: NonNull<Self::Value>) -> RawBytes

Raw text bytes view of a UDF argument value.

unsafe fn value_blob(&self, v: NonNull<Self::Value>) -> RawBytes

Raw blob bytes view of a UDF argument value.

unsafe fn declare_vtab(&self, db: NonNull<Self::Db>, schema: &str) -> Result<()>

Declare a virtual table schema during xCreate/xConnect.

unsafe fn create_module_v2( &self, db: NonNull<Self::Db>, name: &str, module: &'static sqlite3_module<Self>, user_data: *mut c_void, drop_user_data: Option<extern "C" fn(*mut c_void)>, ) -> Result<()>

Register a virtual table module.

impl Sqlite3Backup for LibSqlite3

type Backup = c_void

Backend-specific backup-handle type.

unsafe fn backup_init( &self, dest_db: NonNull<Self::Db>, dest_name: &str, source_db: NonNull<Self::Db>, source_name: &str, ) -> Result<NonNull<Self::Backup>>

Start a backup from source_db/source_name into dest_db/dest_name.

unsafe fn backup_step( &self, backup: NonNull<Self::Backup>, pages: i32, ) -> Result<()>

Copy up to pages pages from source to destination.

unsafe fn backup_remaining(&self, backup: NonNull<Self::Backup>) -> i32

Return the number of pages still remaining.

unsafe fn backup_pagecount(&self, backup: NonNull<Self::Backup>) -> i32

Return the total page count of the source database.

unsafe fn backup_finish(&self, backup: NonNull<Self::Backup>) -> Result<()>

Finish and release a backup handle.

impl Sqlite3BlobIo for LibSqlite3

type Blob = c_void

Backend-specific incremental-blob handle type.

unsafe fn blob_open( &self, db: NonNull<Self::Db>, db_name: &str, table: &str, column: &str, rowid: i64, flags: u32, ) -> Result<NonNull<Self::Blob>>

Open an incremental blob handle for a row/column cell.

unsafe fn blob_read( &self, blob: NonNull<Self::Blob>, data: &mut [u8], offset: i32, ) -> Result<()>

Read bytes from blob into data starting at offset.

unsafe fn blob_write( &self, blob: NonNull<Self::Blob>, data: &[u8], offset: i32, ) -> Result<()>

Write data into blob starting at offset.

unsafe fn blob_bytes(&self, blob: NonNull<Self::Blob>) -> i32

Return blob size in bytes.

unsafe fn blob_close(&self, blob: NonNull<Self::Blob>) -> Result<()>

Close and release a blob handle.

impl Sqlite3Hooks for LibSqlite3

unsafe fn trace_v2( &self, db: NonNull<Self::Db>, mask: u32, callback: Option<extern "C" fn(u32, *mut c_void, *mut c_void, *mut c_void)>, context: *mut c_void, ) -> Result<()>

Register or clear a sqlite3_trace_v2 callback.

unsafe fn progress_handler( &self, db: NonNull<Self::Db>, n: i32, callback: Option<extern "C" fn(*mut c_void) -> i32>, context: *mut c_void, ) -> Result<()>

Register or clear a progress handler callback.

unsafe fn busy_timeout(&self, db: NonNull<Self::Db>, ms: i32) -> Result<()>

Set busy timeout in milliseconds.

unsafe fn set_authorizer( &self, db: NonNull<Self::Db>, callback: Option<extern "C" fn(*mut c_void, i32, *const c_char, *const c_char, *const c_char, *const c_char) -> i32>, context: *mut c_void, ) -> Result<()>

Register or clear an authorizer callback.

impl Sqlite3Metadata for LibSqlite3

unsafe fn table_column_metadata( &self, db: NonNull<Self::Db>, db_name: Option<&str>, table: &str, column: &str, ) -> Result<ColumnMetadata>

Query table/column metadata for the specified schema object.

unsafe fn column_decltype( &self, stmt: NonNull<Self::Stmt>, col: i32, ) -> Option<RawBytes>

Return declared type text for output column col.

unsafe fn column_name( &self, stmt: NonNull<Self::Stmt>, col: i32, ) -> Option<RawBytes>

Return output column name for col.

unsafe fn column_table_name( &self, stmt: NonNull<Self::Stmt>, col: i32, ) -> Option<RawBytes>

Return source table name for output column col, when available.

impl Sqlite3Serialize for LibSqlite3

unsafe fn serialize( &self, db: NonNull<Self::Db>, schema: Option<&str>, flags: u32, ) -> Result<OwnedBytes>

Serialize a schema database into backend-owned bytes.

unsafe fn deserialize( &self, db: NonNull<Self::Db>, schema: Option<&str>, data: &[u8], flags: u32, ) -> Result<()>

Replace schema contents from caller-owned bytes.

unsafe fn free(&self, bytes: OwnedBytes)

Free serialized bytes previously returned by serialize.

impl Sqlite3Wal for LibSqlite3

unsafe fn wal_checkpoint( &self, db: NonNull<Self::Db>, db_name: Option<&str>, ) -> Result<()>

Run a passive checkpoint for db_name (or main when None).

unsafe fn wal_checkpoint_v2( &self, db: NonNull<Self::Db>, db_name: Option<&str>, mode: i32, ) -> Result<(i32, i32)>

Run checkpoint mode mode, returning (log_frames, checkpointed_frames).

unsafe fn wal_frame_count(&self, db: NonNull<Self::Db>) -> Result<Option<u32>>

Return backend-specific WAL frame count when supported.