Struct Read 

pub struct Read<'a, F> { /* private fields */ }

A database read that starts when awaited.

Constructed by CovenHandle::read or CovenReadHandle::read. Await it to receive the fetched values, or attach process to compute a result on separate workers after releasing the database connection.

let titles = handle.read(|sql| {
    Ok(sql.query("SELECT body FROM notes", [], |row| row.get::<_, String>(0))?)
}).process(|mut titles| {
    titles.sort();
    Ok(titles)
}).await?;

Use IntoFuture::into_future when passing the read to an API that requires a Future rather than an awaitable value.

Implementations

impl<'a, F, Raw> Read<'a, F>

where F: for<'connection> FnOnce(SqlReadContext<'connection>) -> CovenResult<Raw> + Send + 'static, Raw: Send + 'static,

pub async fn process<P, R>(self, process: P) -> CovenResult<R>

where P: FnOnce(Raw) -> CovenResult<R> + Send + 'static, R: Send + 'static,

Process the fetched values on bounded workers after the read transaction ends. Fetch every database input in the read closure; the processor receives owned values without a SQL context. A failed read skips it.

Trait Implementations

impl<'a, F, R> IntoFuture for Read<'a, F>

where F: for<'connection> FnOnce(SqlReadContext<'connection>) -> CovenResult<R> + Send + 'static, R: Send + 'static,

type Output = Result<R, CovenError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Read<'a, F> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.