Struct mysql::Conn

pub struct Conn { /* fields omitted */ }

Mysql connection.

Methods

impl Conn

pub fn new<T: Into<Opts>>(opts: T) -> MyResult<Conn>

Creates new Conn.

pub fn reset(&mut self) -> MyResult<()>

Resets MyConn (drops state then reconnects).

pub fn ping(&mut self) -> bool

Executes COM_PING on Conn. Return true on success or false on error.

pub fn select_db(&mut self, schema: &str) -> bool

Executes COM_INIT_DB on Conn.

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

Starts new transaction with provided options. readonly is only available since MySQL 5.6.5.

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

Implements text protocol of mysql server.

Executes mysql query on Conn. QueryResult will borrow Conn until the end of its scope.

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

Performs query and returns first row.

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

Implements binary protocol of mysql server.

Prepares mysql statement on Conn. Stmt will borrow Conn until the end of its scope.

This call will take statement from cache if has been prepared on this connection.

JSON caveats

For the following statement you will get somewhat unexpected result {"a": 0}, because booleans in mysql binary protocol is TINYINT(1) and will be interpreted as 0:

pool.prep_exec(r#"SELECT JSON_REPLACE('{"a": true}', '$.a', ?)"#, (false,));

You should wrap such parameters to a proper json value. For example:

pool.prep_exec(r#"SELECT JSON_REPLACE('{"a": true}', '$.a', ?)"#, (Value::Bool(false),));

Named parameters support

prepare supports named parameters in form of :named_param_name. Allowed characters for parameter name is [a-z_]. Named parameters will be converted to positional before actual call to prepare so SELECT :a-:b, :a*:b is actually SELECT ?-?, ?*?.

// Names could be repeated
pool.prep_exec("SELECT :a+:b, :a * :b, ':c'", params!{"a" => 2, "b" => 3}).map(|mut result| {
    let row = result.next().unwrap().unwrap();
    assert_eq!((5, 6, String::from(":c")), from_row(row));
}).unwrap();

// You can call named statement with positional parameters
pool.prep_exec("SELECT :a+:b, :a*:b", (2, 3, 2, 3)).map(|mut result| {
    let row = result.next().unwrap().unwrap();
    assert_eq!((5, 6), from_row(row));
}).unwrap();

// You must pass all named parameters for statement
let err = pool.prep_exec("SELECT :name", params!{"another_name" => 42}).unwrap_err();
match err {
    DriverError(e) => {
        assert_eq!(MissingNamedParameter("name".into()), e);
    }
    _ => unreachable!(),
}

// You can't call positional statement with named parameters
let err = pool.prep_exec("SELECT ?", params!{"first" => 42}).unwrap_err();
match err {
    DriverError(e) => assert_eq!(NamedParamsForPositionalQuery, e),
    _ => unreachable!(),
}

// You can't mix named and positional parameters
let err = pool.prepare("SELECT :a, ?").unwrap_err();
match err {
    DriverError(e) => assert_eq!(MixedParams, e),
    _ => unreachable!(),
}

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

Prepares and executes statement in one call. See 'Conn::prepare'

This call will take statement from cache if has been prepared on this connection.

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

Executes statement and returns first row.

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

Sets a callback to handle requests for local files. These are caused by using LOAD DATA LOCAL INFILE queries. The callback is passed the filename, and a Writeable object to receive the contents of that file. Specifying None will reset the handler to the one specified in the Opts for this connection.

pub fn no_backslash_escape(&self) -> bool

Trait Implementations

impl GenericConnection for Conn

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

See Conn#query.

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

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, T>(&mut self, query: Q, params: P) -> MyResult<Option<T>> where
    Q: AsRef<str>,
    P: Into<Params>,
    T: FromRow, 

See Conn#first_exec.

impl Drop for Conn

fn drop(&mut self)

Executes the destructor for this type.

impl Debug for Conn

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

Formats the value using the given formatter.