Trait InstrumentedFetch

pub trait InstrumentedFetch<'q, DB: Database>: Sized + Send {
    type Output: Send;

    // Required methods
    fn fetch_one_instrumented<P>(
        self,
        pool: &P,
        sql: impl AsRef<str> + Send,
    ) -> impl Future<Output = Result<Self::Output, Error>> + Send
       where P: InstrumentedPool<Database = DB> + Send + Sync,
             for<'c> &'c P: Executor<'c, Database = DB>;
    fn fetch_optional_instrumented<P>(
        self,
        pool: &P,
        sql: impl AsRef<str> + Send,
    ) -> impl Future<Output = Result<Option<Self::Output>, Error>> + Send
       where P: InstrumentedPool<Database = DB> + Send + Sync,
             for<'c> &'c P: Executor<'c, Database = DB>;
    fn fetch_all_instrumented<P>(
        self,
        pool: &P,
        sql: impl AsRef<str> + Send,
    ) -> impl Future<Output = Result<Vec<Self::Output>, Error>> + Send
       where P: InstrumentedPool<Database = DB> + Send + Sync,
             for<'c> &'c P: Executor<'c, Database = DB>;
}

Required Associated Types

type Output: Send

Required Methods

fn fetch_one_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> impl Future<Output = Result<Self::Output, Error>> + Send

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

fn fetch_optional_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> impl Future<Output = Result<Option<Self::Output>, Error>> + Send

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

fn fetch_all_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> impl Future<Output = Result<Vec<Self::Output>, Error>> + Send

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

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<'q, DB, A> InstrumentedFetch<'q, DB> for Query<'q, DB, A>

where DB: Database, A: 'q + Send + IntoArguments<'q, DB>,

type Output = <DB as Database>::Row

async fn fetch_one_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Self::Output, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_optional_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Option<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_all_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Vec<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

impl<'q, DB, F, A, O> InstrumentedFetch<'q, DB> for Map<'q, DB, F, A>

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

type Output = O

async fn fetch_one_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Self::Output, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_optional_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Option<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_all_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Vec<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

impl<'q, DB, O, A> InstrumentedFetch<'q, DB> for QueryScalar<'q, DB, O, A>

where DB: Database, O: Send + Unpin + for<'r> Decode<'r, DB> + Type<DB>, A: 'q + Send + IntoArguments<'q, DB>, usize: ColumnIndex<DB::Row>,

type Output = O

async fn fetch_one_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Self::Output, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_optional_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Option<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

async fn fetch_all_instrumented<P>( self, pool: &P, sql: impl AsRef<str> + Send, ) -> Result<Vec<Self::Output>, Error>

where P: InstrumentedPool<Database = DB> + Send + Sync, for<'c> &'c P: Executor<'c, Database = DB>,

Implementors