Crate deadpool_sqlite[−][src]

Expand description

Deadpool for SQLite

Deadpool is a dead simple async pool for connections and objects of any type.

This crate implements a deadpool manager for rusqlite and provides a wrapper that ensures correct use of the connection inside a separate thread.

Features

Feature	Description	Extra dependencies	Default
`rt_tokio_1`	Enable support for tokio crate	`deadpool/rt_tokio_1`	yes
`rt_async-std_1`	Enable support for async-std crate	`deadpool/rt_async-std_1`	no
`serde`	Enable support for serde crate	`deadpool/serde`, `serde/derive`	no

Example

use deadpool_sqlite::{Config, Runtime};

#[tokio::main]
async fn main() {
    let mut cfg = Config::new("db.sqlite3");
    let pool = cfg.create_pool(Runtime::Tokio1).unwrap();
    let conn = pool.get().await.unwrap();
    let result: i64 = conn
        .interact(|conn| {
            let mut stmt = conn.prepare("SELECT 1")?;
            let mut rows = stmt.query([])?;
            let row = rows.next()?.unwrap();
            row.get(0)
        })
        .await
        .unwrap();
    assert_eq!(result, 1);
}

License

Licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Re-exports

pub use rusqlite;

Structs

Config

Configuration object.

Manager

Manager for creating and recycling SQLite Connections.

Metrics

Statistics regarding an object returned by the pool

PoolConfig

Pool configuration.

Status

The current pool status.

SyncGuard

This guard is returned when calling SyncWrapper::lock or SyncWrapper::try_lock. This is basicly just a wrapper around a MutexGuard but hides some implementation details.

Timeouts

Timeouts when getting Objects from a Pool.