Struct WriteGuard 

pub struct WriteGuard { /* private fields */ }

RAII guard for exclusive write access to a database connection

This guard wraps a pool connection and returns it to the pool on drop. Only one WriteGuard can exist at a time (enforced by max_connections=1), ensuring serialized write access.

The guard derefs to SqliteConnection allowing direct use with sqlx queries.

Example

use sqlx_sqlite_conn_mgr::SqliteDatabase;
use sqlx::query;

let db = SqliteDatabase::connect("test.db", None).await?;
let mut writer = db.acquire_writer().await?;
// Use &mut *writer for write queries (e.g. INSERT/UPDATE/DELETE)
query("INSERT INTO users (name) VALUES (?)")
    .bind("Alice")
    .execute(&mut *writer)
    .await?;
// Writer is automatically returned when dropped

Methods from Deref<Target = SqliteConnection>

pub async fn serialize( &mut self, schema: Option<&str>, ) -> Result<SqliteOwnedBuf, Error>

Serialize the given SQLite database schema using sqlite3_serialize().

The returned buffer is a SQLite managed allocation containing the equivalent data as writing the database to disk. It is freed on-drop.

To serialize the primary, unqualified schema (main), pass None for the schema name.

Errors

• Error::InvalidArgument if the schema name contains a zero/NUL byte (\0).
• Error::Database if the schema does not exist or another error occurs.

pub async fn deserialize( &mut self, schema: Option<&str>, data: SqliteOwnedBuf, read_only: bool, ) -> Result<(), Error>

Deserialize a SQLite database from a buffer into the specified schema using sqlite3_deserialize().

The given schema will be disconnected and re-connected as an in-memory database backed by data, which should be the serialized form of a database previously returned by a call to Self::serialize(), documented as being equivalent to the contents of the database file on disk.

An error will be returned if a schema with the given name is not already attached.
You can use ATTACH ':memory' as "<schema name>" to create an empty schema first.

Pass None to deserialize to the primary, unqualified schema (main).

The SQLite connection will take ownership of data and will free it when the connection is closed or the schema is detached (SQLITE_DESERIALIZE_FREEONCLOSE).

If read_only is true, the schema is opened as read-only (SQLITE_DESERIALIZE_READONLY).
If false, the schema is marked as resizable (SQLITE_DESERIALIZE_RESIZABLE).

If the database is in WAL mode, an error is returned. See sqlite3_deserialize() for details.

Errors

• Error::InvalidArgument if the schema name contains a zero/NUL byte (\0).
• Error::Database if an error occurs during deserialization.

pub async fn lock_handle(&mut self) -> Result<LockedSqliteHandle<'_>, Error>

Lock the SQLite database handle out from the worker thread so direct SQLite API calls can be made safely.

Returns an error if the worker thread crashed.

Trait Implementations

impl Debug for WriteGuard

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for WriteGuard

type Target = SqliteConnection

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for WriteGuard

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.