Crate mysql

source ·
Expand description


Mysql client library implemented in rust.


Please use mysql crate:

mysql = "*"

rust-mysql-simple offers support of SSL via ssl cargo feature which is disabled by default. Add ssl feature to enable:

version = "*"
features = ["ssl"]
Windows support (since 0.18.0)

Windows is supported but currently rust-mysql-simple has no support of SSL on Windows.

extern crate mysql;
// ...

use mysql as my;

#[derive(Debug, PartialEq, Eq)]
struct Payment {
    customer_id: i32,
    amount: i32,
    account_name: Option<String>,

fn main() {
    // See docs on the `OptsBuilder`'s methods for the list of options available via URL.
    let pool = my::Pool::new("mysql://root:password@localhost:3307/mysql").unwrap();

    // Let's create payment table.
    // Unwrap just to make sure no error happened.
    pool.prep_exec(r"CREATE TEMPORARY TABLE payment (
                         customer_id int not null,
                         amount int not null,
                         account_name text
                     )", ()).unwrap();

    let payments = vec![
        Payment { customer_id: 1, amount: 2, account_name: None },
        Payment { customer_id: 3, amount: 4, account_name: Some("foo".into()) },
        Payment { customer_id: 5, amount: 6, account_name: None },
        Payment { customer_id: 7, amount: 8, account_name: None },
        Payment { customer_id: 9, amount: 10, account_name: Some("bar".into()) },

    // Let's insert payments to the database
    // We will use into_iter() because we do not need to map Stmt to anything else.
    // Also we assume that no error happened in `prepare`.
    for mut stmt in pool.prepare(r"INSERT INTO payment
                                       (customer_id, amount, account_name)
                                       (:customer_id, :amount, :account_name)").into_iter() {
        for p in payments.iter() {
            // `execute` takes ownership of `params` so we pass account name by reference.
            // Unwrap each result just to make sure no errors happened.
                "customer_id" => p.customer_id,
                "amount" => p.amount,
                "account_name" => &p.account_name,

    // Let's select payments from database
    let selected_payments: Vec<Payment> =
    pool.prep_exec("SELECT customer_id, amount, account_name from payment", ())
    .map(|result| { // In this closure we will map `QueryResult` to `Vec<Payment>`
        // `QueryResult` is iterator over `MyResult<row, err>` so first call to `map`
        // will map each `MyResult` to contained `row` (no proper error handling)
        // and second call to `map` will map each `row` to `Payment`|x| x.unwrap()).map(|row| {
            // ⚠️ Note that from_row will panic if you don't follow your schema
            let (customer_id, amount, account_name) = my::from_row(row);
            Payment {
                customer_id: customer_id,
                amount: amount,
                account_name: account_name,
        }).collect() // Collect payments so now `QueryResult` is mapped to `Vec<Payment>`
    }).unwrap(); // Unwrap `Vec<Payment>`

    // Now make sure that `payments` equals to `selected_payments`.
    // Mysql gives no guaranties on order of returned rows without `ORDER BY`
    // so assume we are lukky.
    assert_eq!(payments, selected_payments);


pub extern crate serde;
pub extern crate serde_json;
pub use myc::chrono;
pub use myc::time;
pub use myc::uuid;



This macro is a convenient way to pass named parameters to a statement.


Represents MySql Column (column packet).
Mysql connection.
Use it to parse T: Deserialize from Value.
FromRow conversion error.
FromValue conversion error.
Local in-file stream. The callback will be passed a reference to this stream, which it should use to write the contents of the requested file. See LocalInfileHandler documentation for example.
Callback to handle requests for local files. Consult Mysql documentation for the format of local infile data.
Mysql connection options.
Provides a way to build Opts.
Pool serves to provide you with a PooledConn’s. However you can prepare statements directly on Pool without invoking Pool::get_conn.
Pooled mysql connection which will return to the pool on drop.
Mysql result set for text and binary protocols.
Client side representation of a MySql row.
Use it to pass T: Serialize as JSON to a prepared statement.


Representations of parameters of a prepared statement.
Server error codes (u16)
Client side representation of a value of MySql column.


Will panic if could not convert row to T.
Will return Err(row) if could not convert row to T
Will panic if could not convert v to T
Will return Err(FromValueError(v)) if could not convert v to T

Type Definitions