Struct mysql::PooledConn

pub struct PooledConn { /* fields omitted */ }

Pooled mysql connection which will return to the pool on drop.

You should prefer using prepare or prep_exec instead of query where possible, except cases when statement has no params and when it has no return values or return values which evaluates to Value::Bytes.

query is a part of mysql text protocol, so under the hood you will always receive Value::Bytes as a result and from_value will need to parse it if you want, for example, i64

let pool = Pool::new(get_opts()).unwrap();
let mut conn = pool.get_conn().unwrap();

conn.query_first("SELECT 42").map(|result: Option<Value>| {
    let result = result.unwrap();
    assert_eq!(result, Value::Bytes(b"42".to_vec()));
    assert_eq!(from_value::<i64>(result), 42i64);
}).unwrap();
conn.exec_iter("SELECT 42", ()).map(|mut result| {
    let cell = result.next().unwrap().unwrap().take(0).unwrap();
    assert_eq!(cell, Value::Int(42i64));
    assert_eq!(from_value::<i64>(cell), 42i64);
}).unwrap();

For more info on how to work with query results please look at QueryResult documentation.

Implementations

impl PooledConn

pub fn start_transaction(&mut self, tx_opts: TxOpts) -> Result<Transaction<'_>>

Redirects to Conn#start_transaction

pub fn as_mut(&mut self) -> &mut Conn

Gives mutable reference to the wrapped Conn.

pub fn as_ref(&self) -> &Conn

Gives reference to the wrapped Conn.

pub fn unwrap(self) -> Conn

Unwraps wrapped Conn.

pub fn set_local_infile_handler(&mut self, handler: Option<LocalInfileHandler>)

A way to override default local infile handler for this pooled connection. Destructor will restore original handler before returning connection to a pool. See Conn::set_local_infile_handler.

Methods from Deref<Target = Conn>

pub fn connection_id(&self) -> u32

Returns connection identifier.

pub fn affected_rows(&self) -> u64

Returns number of rows affected by the last query.

pub fn last_insert_id(&self) -> u64

Returns last insert id of the last query.

Returns zero if there was no last insert id.

pub fn warnings(&self) -> u16

Returns number of warnings, reported by the server.

pub fn info_ref(&self) -> &[u8]

Info, reported by the server.

Will be empty if not defined.

pub fn info_str(&self) -> Cow<'_, str>

Info, reported by the server.

Will be empty if not defined.

pub fn no_backslash_escape(&self) -> bool

Trait Implementations

impl Debug for PooledConn

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

Formats the value using the given formatter.

impl Deref for PooledConn

type Target = Conn

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for PooledConn

fn drop(&mut self)

Executes the destructor for this type.

impl Queryable for PooledConn

fn query_iter<T: AsRef<str>>(
    &mut self,
    query: T
) -> Result<QueryResult<'_, '_, '_, Text>>

Perfoms text query.

fn prep<T: AsRef<str>>(&mut self, query: T) -> Result<Statement>

Prepares the given query as a prepared statement.

fn close(&mut self, stmt: Statement) -> Result<()>

This function will close the given statement on the server side.

fn exec_iter<S, P>(
    &mut self,
    stmt: S,
    params: P
) -> Result<QueryResult<'_, '_, '_, Binary>> where
    S: AsStatement,
    P: Into<Params>, 

Executes the given stmt with the given params.

fn query<T, Q>(&mut self, query: Q) -> Result<Vec<T>> where
    Q: AsRef<str>,
    T: FromRow, 

Performs text query and collects the first result set.

fn query_opt<T, Q>(
    &mut self,
    query: Q
) -> Result<Vec<StdResult<T, FromRowError>>> where
    Q: AsRef<str>,
    T: FromRow, 

Same as Queryable::query but useful when you not sure what your schema is.

fn query_first<T, Q>(&mut self, query: Q) -> Result<Option<T>> where
    Q: AsRef<str>,
    T: FromRow, 

Performs text query and returns the firt row of the first result set.

fn query_first_opt<T, Q>(
    &mut self,
    query: Q
) -> Result<Option<StdResult<T, FromRowError>>> where
    Q: AsRef<str>,
    T: FromRow, 

Same as Queryable::query_first but useful when you not sure what your schema is.

fn query_map<T, F, Q, U>(&mut self, query: Q, f: F) -> Result<Vec<U>> where
    Q: AsRef<str>,
    T: FromRow,
    F: FnMut(T) -> U, 

Performs text query and maps each row of the first result set.

fn query_map_opt<T, F, Q, U>(&mut self, query: Q, f: F) -> Result<Vec<U>> where
    Q: AsRef<str>,
    T: FromRow,
    F: FnMut(StdResult<T, FromRowError>) -> U, 

Same as Queryable::query_map but useful when you not sure what your schema is.

fn query_fold<T, F, Q, U>(&mut self, query: Q, init: U, f: F) -> Result<U> where
    Q: AsRef<str>,
    T: FromRow,
    F: FnMut(U, T) -> U, 

Performs text query and folds the first result set to a single value.

fn query_fold_opt<T, F, Q, U>(&mut self, query: Q, init: U, f: F) -> Result<U> where
    Q: AsRef<str>,
    T: FromRow,
    F: FnMut(U, StdResult<T, FromRowError>) -> U, 

Same as Queryable::query_fold but useful when you not sure what your schema is.

fn query_drop<Q>(&mut self, query: Q) -> Result<()> where
    Q: AsRef<str>, 

Performs text query and drops the query result.

fn exec_batch<S, P, I>(&mut self, stmt: S, params: I) -> Result<()> where
    Self: Sized,
    S: AsStatement,
    P: Into<Params>,
    I: IntoIterator<Item = P>, 

Prepares the given statement, and executes it with each item in the given params iterator.

fn exec<T, S, P>(&mut self, stmt: S, params: P) -> Result<Vec<T>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow, 

Executes the given stmt and collects the first result set.

fn exec_opt<T, S, P>(
    &mut self,
    stmt: S,
    params: P
) -> Result<Vec<StdResult<T, FromRowError>>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow, 

Same as Queryable::exec but useful when you not sure what your schema is.

fn exec_first<T, S, P>(&mut self, stmt: S, params: P) -> Result<Option<T>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow, 

Executes the given stmt and returns the first row of the first result set.

fn exec_first_opt<T, S, P>(
    &mut self,
    stmt: S,
    params: P
) -> Result<Option<StdResult<T, FromRowError>>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow, 

Same as Queryable::exec_first but useful when you not sure what your schema is.

fn exec_map<T, S, P, F, U>(
    &mut self,
    stmt: S,
    params: P,
    f: F
) -> Result<Vec<U>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow,
    F: FnMut(T) -> U, 

Executes the given stmt and maps each row of the first result set.

fn exec_map_opt<T, S, P, F, U>(
    &mut self,
    stmt: S,
    params: P,
    f: F
) -> Result<Vec<U>> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow,
    F: FnMut(StdResult<T, FromRowError>) -> U, 

Same as Queryable::exec_map but useful when you not sure what your schema is.

fn exec_fold<T, S, P, U, F>(
    &mut self,
    stmt: S,
    params: P,
    init: U,
    f: F
) -> Result<U> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow,
    F: FnMut(U, T) -> U, 

Executes the given stmt and folds the first result set to a signel value.

fn exec_fold_opt<T, S, P, U, F>(
    &mut self,
    stmt: S,
    params: P,
    init: U,
    f: F
) -> Result<U> where
    S: AsStatement,
    P: Into<Params>,
    T: FromRow,
    F: FnMut(U, StdResult<T, FromRowError>) -> U, 

Same as Queryable::exec_fold but useful when you not sure what your schema is.

fn exec_drop<S, P>(&mut self, stmt: S, params: P) -> Result<()> where
    S: AsStatement,
    P: Into<Params>, 

Executes the given stmt and drops the result.