Struct RusqliteService 

pub struct RusqliteService {
    writer: Arc<Writer>,
    readers: Option<Arc<ReaderPool>>,
}

Rusqlite-based database service: a cheap, cloneable handle to the writer thread and reader pool. See the module docs.

Fields

writer: Arc<Writer>

readers: Option<Arc<ReaderPool>>

Implementations

impl RusqliteService

pub fn new(conn: Arc<Mutex<Connection>>) -> Self

A service over a single connection: writes and reads go through the writer thread. Used for in-memory databases, which cannot be shared between connections.

pub fn with_readers( conn: Arc<Mutex<Connection>>, readers: Vec<Connection>, ) -> Self

A service whose reads run on readers — read-only connections to the same (file-backed, WAL-mode) database — alongside the writer.

async fn read<T, F>(&self, f: F) -> Result<T, String>

where T: Send + 'static, F: FnOnce(&Connection) -> Result<T, String> + Send + 'static,

Trait Implementations

impl Clone for RusqliteService

fn clone(&self) -> RusqliteService

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DatabaseService for RusqliteService

fn execute<'life0, 'async_trait>( &'life0 self, query: Query, ) -> Pin<Box<dyn Future<Output = Result<usize, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute a query that doesn’t return results (INSERT, UPDATE, DELETE)

fn execute_batch<'life0, 'life1, 'async_trait>( &'life0 self, sql: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a batch of SQL statements (for migrations)

fn query_one<'life0, 'async_trait, T, F>( &'life0 self, query: Query, mapper: F, ) -> Pin<Box<dyn Future<Output = Result<T, String>> + Send + 'async_trait>>

where T: Send + 'static + 'async_trait, F: Fn(&Row<'_>) -> SqliteResult<T> + Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Query a single row

fn query_optional<'life0, 'async_trait, T, F>( &'life0 self, query: Query, mapper: F, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, String>> + Send + 'async_trait>>

where T: Send + 'static + 'async_trait, F: Fn(&Row<'_>) -> SqliteResult<T> + Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Query a single optional row

fn query_many<'life0, 'async_trait, T, F>( &'life0 self, query: Query, mapper: F, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, String>> + Send + 'async_trait>>

where T: Send + 'static + 'async_trait, F: Fn(&Row<'_>) -> SqliteResult<T> + Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Query multiple rows

fn transaction<'life0, 'async_trait, F, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, String>> + Send + 'async_trait>>

where F: FnOnce(&mut Transaction<'_>) -> Result<T, String> + Send + 'static + 'async_trait, T: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Run a transaction with multiple operations

fn transaction_without_foreign_keys<'life0, 'async_trait, F, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, String>> + Send + 'async_trait>>

where F: FnOnce(&mut Transaction<'_>) -> Result<T, String> + Send + 'static + 'async_trait, T: Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Run a transaction with foreign-key enforcement switched off for its duration only.

fn insert<'life0, 'async_trait>( &'life0 self, query: Query, ) -> Pin<Box<dyn Future<Output = Result<i64, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute an INSERT and return the rowid of the row it inserted.

fn execute_detached(&self, query: Query)

Queue a write without waiting for it — for best-effort bookkeeping (an LRU access time) that must not hold up the caller. It still runs in order with every other write; failures are only logged.