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.
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 |
tracing | Enable support for tracing by propagating Spans in the interact() calls. Enable this if you use the tracing crate and you want to get useful traces from within interact() calls. | deadpool-sync/tracing , tracing | no |
use deadpool_sqlite::{Config, Runtime};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
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??;
assert_eq!(result, 1);
Ok(())
}
Licensed under either of
at your option.
pub use rusqlite;
Manager
for creating and recycling SQLite Connection
s.Pool
configuration.SyncWrapper::lock
or
SyncWrapper::try_lock
. This is basicly just a wrapper around
a MutexGuard
but hides some implementation details.SyncWrapper::interact()
fails.deadpool::managed::BuildError
with rusqlite
.Object
deadpool::managed::CreatePoolError
with rusqlite
.deadpool::managed::Hook
with rusqlite
.deadpool::managed::HookError
with rusqlite
.deadpool::managed::Object
with rusqlite
.deadpool::managed::Pool
with rusqlite
.deadpool::managed::PoolBuilder
with rusqlite
.deadpool::managed::PoolError
with rusqlite
.