Struct Db 

pub struct Db {
    connection: SqliteConnection,
}

Fields

connection: SqliteConnection

Implementations

impl Db

pub async fn open(path: &Path) -> Result<Self, DbError>

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 DerefMut for Db

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

Mutably dereferences the value.

impl From<Db> for DbBackend

fn from(db: Db) -> Self

Converts to this type from the input type.

impl Deref for Db

type Target = SqliteConnection

The resulting type after dereferencing.

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

Dereferences the value.