Struct OneTimeExecutor 

pub struct OneTimeExecutor<'c, E>
where
    E: PgExecutor<'c>,
{ /* private fields */ }

A struct that owns an sqlx::Executor.

Calling one of the fetch_ fns will consume it thus garuanteeing a 1 time usage.

It is not used directly but passed via the IntoOneTimeExecutor trait.

In order to make the consumption of the executor work we have to pass the query to the executor:

async fn query(ex: impl es_entity::IntoOneTimeExecutor<'_>) -> Result<(), sqlx::Error> {
    ex.into_executor().fetch_optional(
        sqlx::query!(
            "SELECT NOW()"
        )
    ).await?;
    Ok(())
}

Implementations

impl<'c, E> OneTimeExecutor<'c, E>

where E: PgExecutor<'c>,

pub fn maybe_now(&self) -> Option<DateTime<Utc>>

pub async fn fetch_one<'q, F, O, A>( self, query: Map<'q, Postgres, F, A>, ) -> Result<O, Error>

where F: FnMut(PgRow) -> Result<O, Error> + Send, O: Send + Unpin, A: 'q + Send + IntoArguments<'q, Postgres>,

Proxy call to query.fetch_one but guarantees the inner executor will only be used once.

pub async fn fetch_all<'q, F, O, A>( self, query: Map<'q, Postgres, F, A>, ) -> Result<Vec<O>, Error>

where F: FnMut(PgRow) -> Result<O, Error> + Send, O: Send + Unpin, A: 'q + Send + IntoArguments<'q, Postgres>,

Proxy call to query.fetch_all but guarantees the inner executor will only be used once.

pub async fn fetch_optional<'q, F, O, A>( self, query: Map<'q, Postgres, F, A>, ) -> Result<Option<O>, Error>

where F: FnMut(PgRow) -> Result<O, Error> + Send, O: Send + Unpin, A: 'q + Send + IntoArguments<'q, Postgres>,

Proxy call to query.fetch_optional but guarantees the inner executor will only be used once.

Trait Implementations

impl<'c, E> IntoOneTimeExecutorAt<'c> for OneTimeExecutor<'c, E>

where E: PgExecutor<'c> + 'c,

type Executor = E

The concrete executor type.

fn into_executor(self) -> OneTimeExecutor<'c, Self::Executor>

where Self: 'c,

Transforms into a OneTimeExecutor which can be used to execute a round trip.