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 mut conn = pool.get_conn().unwrap();

conn.query("SELECT 42").map(|mut result| {
    let cell = result.next().unwrap().unwrap().take(0).unwrap();
    assert_eq!(cell, Value::Bytes(b"42".to_vec()));
    assert_eq!(from_value::<i64>(cell), 42i64);
}).unwrap();
conn.prep_exec("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.

Methods

impl PooledConn

fn query<T: AsRef<str>>(&mut self, query: T) -> MyResult<QueryResult>

Redirects to Conn#query.

fn first<T: AsRef<str>>(&mut self, query: T) -> MyResult<Option<Row>>

See Conn::first.

fn prepare<T: AsRef<str>>(&mut self, query: T) -> MyResult<Stmt>

See Conn::prepare.

fn prep_exec<A, T>(&mut self, query: A, params: T) -> MyResult<QueryResult> where A: AsRef<str>, T: Into<Params>

See Conn::prep_exec.

fn first_exec<Q, P>(&mut self, query: Q, params: P) -> MyResult<Option<Row>> where Q: AsRef<str>, P: Into<Params>

See Conn::first_exec.

fn start_transaction<'a>(&'a mut self,
                         consistent_snapshot: bool,
                         isolation_level: Option<IsolationLevel>,
                         readonly: Option<bool>)
                         -> MyResult<Transaction<'a>>

Redirects to Conn#start_transaction

fn as_mut<'a>(&'a mut self) -> &'a mut Conn

Gives mutable reference to the wrapped Conn.

fn as_ref<'a>(&'a self) -> &'a Conn

Gives reference to the wrapped Conn.

fn unwrap(self) -> Conn

Unwraps wrapped Conn.

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.

Trait Implementations

impl Debug for PooledConn

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Drop for PooledConn

fn drop(&mut self)

A method called when the value goes out of scope.

impl GenericConnection for PooledConn

fn query<T: AsRef<str>>(&mut self, query: T) -> MyResult<QueryResult>

See Conn#query.

fn first<T: AsRef<str>>(&mut self, query: T) -> MyResult<Option<Row>>

See Conn#first.

fn prepare<T: AsRef<str>>(&mut self, query: T) -> MyResult<Stmt>

See Conn#prepare.

fn prep_exec<A, T>(&mut self, query: A, params: T) -> MyResult<QueryResult> where A: AsRef<str>, T: Into<Params>

See Conn#prep_exec.

fn first_exec<Q, P>(&mut self, query: Q, params: P) -> MyResult<Option<Row>> where Q: AsRef<str>, P: Into<Params>

See Conn#first_exec.