Struct AttachedWriteGuard 

pub struct AttachedWriteGuard { /* private fields */ }

Guard holding a write connection with attached database(s)

Important: Call detach_all() before dropping to properly clean up attached databases. Without explicit cleanup, attached databases persist on the pooled connection until it’s eventually closed. Derefs to SqliteConnection for executing queries.

Implementations

impl AttachedWriteGuard

pub async fn detach_all(self) -> Result<()>

Explicitly detach all attached databases.

This method should be called before dropping the connection to ensure attached databases are properly cleaned up. Without calling this, attached databases may persist when the connection is returned to the pool.

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 AttachedWriteGuard

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

Formats the value using the given formatter.

impl Deref for AttachedWriteGuard

type Target = SqliteConnection

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for AttachedWriteGuard

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

Mutably dereferences the value.

impl Drop for AttachedWriteGuard

fn drop(&mut self)

Executes the destructor for this type.