Struct OneTimeExecutor 

pub struct OneTimeExecutor<'c, E>
where
    E: Executor<'c, Database = Db> + '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: Executor<'c, Database = Db> + 'c,

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

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

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

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> Debug for OneTimeExecutor<'c, E>

where E: Executor<'c, Database = Db> + 'c + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

where E: Executor<'c, Database = Db> + 'c,

type Database = Postgres

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Db as Database>::QueryResult, Row>, Error>>

where Q: 'q + Execute<'q, Db>, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<Row>, Error>>

where Q: 'q + Execute<'q, Db>, 'c: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Db as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Db as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Statement<'q>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.

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

where E: Executor<'c, Database = Db> + '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.