Struct mysql::PooledConn

pub struct PooledConn { /* private fields */ }

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

You should prefer using prep along exec instead of query from the Queryable trait 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 get_binlog_stream(
    self,
    request: BinlogRequest<'_>
) -> Result<BinlogStream>

Turns this connection into a binlog stream (see Conn::get_binlog_stream).

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 server_version(&self) -> (u16, u16, u16)

Returns version number reported by the server.

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 session_state_changes(&self) -> Result<Vec<SessionStateInfo<'_>>>

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 first 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.