Trait BinQuery

pub trait BinQuery: Sized {
    // Required method
    fn run<'a, 'b, 'c, C>(
        self,
        conn: C,
    ) -> Result<QueryResult<'a, 'b, 'c, Binary>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>;

    // Provided methods
    fn first<'a, 'b, 'c: 'b, T, C>(self, conn: C) -> Result<Option<T>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow { ... }
    fn first_opt<'a, 'b, 'c: 'b, T, C>(
        self,
        conn: C,
    ) -> Result<Option<StdResult<T, FromRowError>>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow { ... }
    fn fetch<'a, 'b, 'c: 'b, T, C>(self, conn: C) -> Result<Vec<T>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow { ... }
    fn fetch_opt<'a, 'b, 'c: 'b, T, C>(
        self,
        conn: C,
    ) -> Result<Vec<StdResult<T, FromRowError>>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow { ... }
    fn fold<'a, 'b, 'c: 'b, T, U, F, C>(
        self,
        conn: C,
        init: U,
        next: F,
    ) -> Result<U>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow,
             F: FnMut(U, T) -> U { ... }
    fn fold_opt<'a, 'b, 'c: 'b, T, U, F, C>(
        self,
        conn: C,
        init: U,
        next: F,
    ) -> Result<U>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow,
             F: FnMut(U, StdResult<T, FromRowError>) -> U { ... }
    fn map<'a, 'b, 'c: 'b, T, U, F, C>(self, conn: C, map: F) -> Result<Vec<U>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow,
             F: FnMut(T) -> U { ... }
    fn map_opt<'a, 'b, 'c: 'b, T, U, F, C>(
        self,
        conn: C,
        map: F,
    ) -> Result<Vec<U>>
       where C: TryInto<ConnMut<'a, 'b, 'c>>,
             Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,
             T: FromRow,
             F: FnMut(StdResult<T, FromRowError>) -> U { ... }
}

MySql prepared statement query.

This trait covers the set of exec* methods on the Queryable trait. Please see the corresponding section of the crate level docs for details.

Example:

use mysql::*;
use mysql::prelude::*;
let pool = Pool::new(get_opts())?;

let num: Option<u32> = "SELECT ?"
    .with((42,))
    .first(&pool)?;

assert_eq!(num, Some(42));

Required Methods

fn run<'a, 'b, 'c, C>(self, conn: C) -> Result<QueryResult<'a, 'b, 'c, Binary>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>,

This methods corresponds to Queryable::exec_iter.

Provided Methods

fn first<'a, 'b, 'c: 'b, T, C>(self, conn: C) -> Result<Option<T>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow,

This methods corresponds to Queryable::exec_first.

fn first_opt<'a, 'b, 'c: 'b, T, C>( self, conn: C, ) -> Result<Option<StdResult<T, FromRowError>>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow,

Same as BinQuery::first but useful when you not sure what your schema is.

fn fetch<'a, 'b, 'c: 'b, T, C>(self, conn: C) -> Result<Vec<T>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow,

This methods corresponds to Queryable::exec.

fn fetch_opt<'a, 'b, 'c: 'b, T, C>( self, conn: C, ) -> Result<Vec<StdResult<T, FromRowError>>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow,

Same as BinQuery::fetch but useful when you not sure what your schema is.

fn fold<'a, 'b, 'c: 'b, T, U, F, C>( self, conn: C, init: U, next: F, ) -> Result<U>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow, F: FnMut(U, T) -> U,

This methods corresponds to Queryable::exec_fold.

fn fold_opt<'a, 'b, 'c: 'b, T, U, F, C>( self, conn: C, init: U, next: F, ) -> Result<U>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow, F: FnMut(U, StdResult<T, FromRowError>) -> U,

Same as BinQuery::fold but useful when you not sure what your schema is.

fn map<'a, 'b, 'c: 'b, T, U, F, C>(self, conn: C, map: F) -> Result<Vec<U>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow, F: FnMut(T) -> U,

This methods corresponds to Queryable::exec_map.

fn map_opt<'a, 'b, 'c: 'b, T, U, F, C>(self, conn: C, map: F) -> Result<Vec<U>>

where C: TryInto<ConnMut<'a, 'b, 'c>>, Error: From<<C as TryInto<ConnMut<'a, 'b, 'c>>>::Error>, T: FromRow, F: FnMut(StdResult<T, FromRowError>) -> U,

Same as BinQuery::map but useful when you not sure what your schema is.

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.

Implementors

impl<Q, P> BinQuery for QueryWithParams<Q, P>

where Q: AsStatement, P: Into<Params>,