Struct Connection 

pub struct Connection<'p, P: Sqlite3Api> { /* private fields */ }

Safe wrapper around a sqlite3* connection.

Implementations

impl<'p, P: Sqlite3Api> Connection<'p, P>

pub fn open( api: &'p P, filename: &str, options: OpenOptions<'_>, ) -> Result<Self>

Open a connection using the provider SPI.

pub fn prepare(&self, sql: &str) -> Result<Statement<'_, 'p, P>>

Prepare a statement, using prepare_v3 when available.

pub fn prepare_with_flags( &self, sql: &str, flags: u32, ) -> Result<Statement<'_, 'p, P>>

Prepare a statement with flags (requires prepare_v3 support).

pub fn raw_handle(&self) -> NonNull<P::Db>

Expose the raw database handle.

impl<'p, P: Sqlite3Keying> Connection<'p, P>

pub fn open_with_key( api: &'p P, filename: &str, options: OpenOptions<'_>, key: &[u8], ) -> Result<Self>

Open a connection and immediately apply a key (SQLCipher-style).

pub fn rekey(&self, key: &[u8]) -> Result<()>

Rekey the database (SQLCipher-style).

impl<'p, P: Sqlite3Backup> Connection<'p, P>

pub fn backup_to<'c>( &'c self, dest: &'c Connection<'p, P>, name: &str, ) -> Result<Backup<'c, 'p, P>>

Start a backup from this database to dest.

impl<'p, P: Sqlite3BlobIo> Connection<'p, P>

pub fn open_blob<'c>( &'c self, db_name: &str, table: &str, column: &str, rowid: i64, flags: u32, ) -> Result<Blob<'c, 'p, P>>

Open an incremental blob handle.

impl<'p, P: Sqlite3Serialize> Connection<'p, P>

pub fn serialize( &self, schema: Option<&str>, flags: u32, ) -> Result<SerializedDb<'p, P>>

Serialize the database into an owned buffer.

pub fn deserialize( &self, schema: Option<&str>, data: &[u8], flags: u32, ) -> Result<()>

Deserialize bytes into the database.

impl<'p, P: Sqlite3Wal> Connection<'p, P>

pub fn wal_checkpoint(&self, db_name: Option<&str>) -> Result<()>

Run a WAL checkpoint.

pub fn wal_checkpoint_v2( &self, db_name: Option<&str>, mode: i32, ) -> Result<(i32, i32)>

Run a WAL checkpoint with a mode, returning (log, checkpointed) page counts.

pub fn wal_frame_count(&self) -> Result<Option<u32>>

Return libsql WAL frame count if supported.

impl<'p, P: Sqlite3Metadata> Connection<'p, P>

pub fn table_column_metadata( &self, db_name: Option<&str>, table: &str, column: &str, ) -> Result<ColumnMetadata>

Fetch column metadata for a table.

impl<'p, P: Sqlite3Hooks> Connection<'p, P>

pub fn busy_timeout(&self, ms: i32) -> Result<()>

Set busy timeout.

pub unsafe fn progress_handler_raw( &self, n: i32, cb: Option<extern "C" fn(*mut c_void) -> i32>, context: *mut c_void, ) -> Result<()>

Register or clear a raw progress callback.

Safety

Callers must ensure the callback/context pair remains valid until it is explicitly cleared and that the callback never unwinds.

pub fn register_progress_handler<'c, F>( &'c self, n: i32, f: F, ) -> Result<CallbackHandle<'c, 'p, P>>

where F: FnMut() -> i32 + Send + 'static,

Register a panic-contained progress callback.

The callback is invoked through a trampoline that catches panics and returns 1 on unwind so SQLite interrupts execution (fail-closed).

pub fn clear_progress_handler(&self) -> Result<()>

Remove any previously registered progress callback.

pub fn register_trace<'c, F>( &'c self, mask: TraceMask, f: F, ) -> Result<CallbackHandle<'c, 'p, P>>

where F: for<'a> FnMut(TraceEvent<'a, P>) + Send + 'static,

Register a typed trace callback.

pub fn register_authorizer<'c, F>( &'c self, f: F, ) -> Result<CallbackHandle<'c, 'p, P>>

where F: FnMut(AuthorizerEvent<'_>) -> AuthorizerResult + Send + 'static,

Register a typed authorizer callback.

impl<'p, P: Sqlite3Api> Connection<'p, P>

pub fn create_scalar_function<F>( &self, name: &str, n_args: i32, func: F, ) -> Result<()>

where F: for<'a> FnMut(&Context<'a, P>, &[ValueRef<'a>]) -> Result<Value> + Send + 'static,

Register a scalar function (xFunc).

pub fn create_aggregate_function<T, Init, Step, Final>( &self, name: &str, n_args: i32, init: Init, step: Step, final_fn: Final, ) -> Result<()>

where T: Send + 'static, Init: Fn() -> T + Send + 'static, Step: for<'a> FnMut(&Context<'a, P>, &mut T, &[ValueRef<'a>]) -> Result<()> + Send + 'static, Final: for<'a> FnMut(&Context<'a, P>, T) -> Result<Value> + Send + 'static,

Register an aggregate function (xStep/xFinal).

State is stored out-of-line in a Rust Box<T> and the SQLite aggregate context keeps only a pointer-sized slot, so T alignment does not depend on backend aggregate-context allocation alignment.

pub fn create_window_function<T, Init, Step, Inverse, ValueFn, Final>( &self, name: &str, n_args: i32, init: Init, step: Step, inverse: Inverse, value_fn: ValueFn, final_fn: Final, ) -> Result<()>

where T: Send + 'static, Init: Fn() -> T + Send + 'static, Step: for<'a> FnMut(&Context<'a, P>, &mut T, &[ValueRef<'a>]) -> Result<()> + Send + 'static, Inverse: for<'a> FnMut(&Context<'a, P>, &mut T, &[ValueRef<'a>]) -> Result<()> + Send + 'static, ValueFn: for<'a> FnMut(&Context<'a, P>, &mut T) -> Result<Value> + Send + 'static, Final: for<'a> FnMut(&Context<'a, P>, T) -> Result<Value> + Send + 'static,

Register a window function (xStep/xInverse/xValue/xFinal).

State is stored out-of-line in a Rust Box<T> and the SQLite aggregate context keeps only a pointer-sized slot, so T alignment does not depend on backend aggregate-context allocation alignment.

impl<'p, P: Sqlite3Api> Connection<'p, P>

pub fn create_module<T>(&self, name: &str) -> Result<()>

where P: Sqlite3Api<VTab = VTab<P, T>, VTabCursor = Cursor<P, T::Cursor>>, T: VirtualTable<P>,

Register a virtual table module using the default glue.

Trait Implementations

impl<'p, P: Sqlite3Api> Drop for Connection<'p, P>

fn drop(&mut self)

Executes the destructor for this type.