Trait QueryExecutor 

pub trait QueryExecutor: Sized {
    // Required methods
    fn query<R, A>(
        self,
        query: impl AsRef<str> + Send,
        arguments: &A,
    ) -> impl Future<Output = Result<Vec<R>, Error>> + Send
       where A: QueryArgs,
             R: QueryResult + Send;
    fn query_verbose<R, A>(
        self,
        query: impl AsRef<str> + Send,
        arguments: &A,
    ) -> impl Future<Output = Result<ResultVerbose<Vec<R>>, Error>> + Send
       where A: QueryArgs,
             R: QueryResult + Send;
    fn query_single<R, A>(
        self,
        query: impl AsRef<str> + Send,
        arguments: &A,
    ) -> impl Future<Output = Result<Option<R>, Error>> + Send
       where A: QueryArgs,
             R: QueryResult + Send;
    fn query_required_single<R, A>(
        self,
        query: impl AsRef<str> + Send,
        arguments: &A,
    ) -> impl Future<Output = Result<R, Error>> + Send
       where A: QueryArgs,
             R: QueryResult + Send;
    fn query_json(
        self,
        query: &str,
        arguments: &impl QueryArgs,
    ) -> impl Future<Output = Result<Json, Error>> + Send;
    fn query_single_json(
        self,
        query: &str,
        arguments: &impl QueryArgs,
    ) -> impl Future<Output = Result<Option<Json>, Error>> + Send;
    fn query_required_single_json(
        self,
        query: &str,
        arguments: &impl QueryArgs,
    ) -> impl Future<Output = Result<Json, Error>>;
    fn execute<A>(
        self,
        query: &str,
        arguments: &A,
    ) -> impl Future<Output = Result<(), Error>> + Send
       where A: QueryArgs;
}

Abstracts over different query executors In particular &Client and &mut Transaction

Required Methods

fn query<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<Vec<R>, Error>> + Send

where A: QueryArgs, R: QueryResult + Send,

see Client::query

fn query_verbose<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<ResultVerbose<Vec<R>>, Error>> + Send

where A: QueryArgs, R: QueryResult + Send,

see Client::query_verbose

fn query_single<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<Option<R>, Error>> + Send

where A: QueryArgs, R: QueryResult + Send,

see Client::query_single

fn query_required_single<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<R, Error>> + Send

where A: QueryArgs, R: QueryResult + Send,

see Client::query_required_single

fn query_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Json, Error>> + Send

see Client::query_json

fn query_single_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Option<Json>, Error>> + Send

see Client::query_single_json

fn query_required_single_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Json, Error>>

see Client::query_required_single_json

fn execute<A>( self, query: &str, arguments: &A, ) -> impl Future<Output = Result<(), Error>> + Send

where A: QueryArgs,

see Client::execute

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T: DerefMut<Target = Transaction>> QueryExecutor for &mut T

fn query<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<Vec<R>, Error>>

where A: QueryArgs, R: QueryResult,

fn query_verbose<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<ResultVerbose<Vec<R>>, Error>> + Send

where A: QueryArgs, R: QueryResult + Send,

fn query_single<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<Option<R>, Error>>

where A: QueryArgs, R: QueryResult + Send,

fn query_required_single<R, A>( self, query: impl AsRef<str> + Send, arguments: &A, ) -> impl Future<Output = Result<R, Error>>

where A: QueryArgs, R: QueryResult + Send,

fn query_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Json, Error>>

fn query_single_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Option<Json>, Error>>

fn query_required_single_json( self, query: &str, arguments: &impl QueryArgs, ) -> impl Future<Output = Result<Json, Error>>

fn execute<A>( self, query: &str, arguments: &A, ) -> impl Future<Output = Result<(), Error>>

where A: QueryArgs,

Implementors

impl QueryExecutor for &Client