Crate mysql

rust-mysql-simple

Mysql client library implemented in rust nightly.

Install

Please use mysql crate:

[dependencies]
mysql = "*"

rust-mysql-simple offers support of SSL via ssl cargo feature which is enabled by default. If you have no plans to use SSL, then you should disable that feature to not to depend on rust-openssl:

[dependencies.mysql]
mysql = "*"
default-features = false
features = ["socket"]

Windows support (since 0.18.0)

Currently rust-mysql-simple has no support for SSL on Windows.

[dependencies.mysql]
mysql = "*"
default-features = false
features = ["pipe"]

Example

use mysql as my;

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

fn main() {
    let pool = my::Pool::new("mysql://root:password@localhost:3307").unwrap();

    // Let's create payment table.
    // It is temporary so we do not need `tmp` database to exist.
    // Unwap just to make sure no error happened.
    pool.prep_exec(r"CREATE TEMPORARY TABLE tmp.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 tmp.payment
                                       (customer_id, amount, account_name)
                                   VALUES
                                       (?, ?, ?)").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 happended.
            stmt.execute((p.customer_id, p.amount, &p.account_name)).unwrap();
        }
    }

    // Let's select payments from database
    let selected_payments: Vec<Payment> =
    pool.prep_exec("SELECT customer_id, amount, account_name from tmp.payment", ())
    .map(|result| { // In this closure we sill 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`
        result.map(|x| x.unwrap()).map(|row| {
            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);
    println!("Yay!");
}

Modules

conn
consts
error
value

Structs

Column	Mysql Column.
Conn	Mysql connection.
MySqlError
Opts	Mysql connection options.
OptsBuilder	Provides a way to build Opts.
Pool	Pool serves to provide you with a PooledConn's. However you can prepare statements directly on Pool without invoking Pool::get_conn.
PooledConn	Pooled mysql connection which will return to the pool on drop.
QueryResult	Mysql result set for text and binary protocols.
Row	Mysql row representation.
Stmt	Mysql prepared statement.
Transaction

Enums

DriverError
Error
IsolationLevel
Params
ServerError	Server error codes (u16)
UrlError
Value	Value enumerates possible values in mysql cells. Also Value used to fill prepared statements.

Traits

ConvIr	Basic operations on FromValue conversion intermediate result.
FromRow	Trait to convert Row into tuple of FromValue implementors up to arity 12.
FromValue	Implement this trait to convert value to something.
ToValue

Functions

from_row	Will panic if could not convert row to T.
from_row_opt	Will return Err(row) if could not convert row to T
from_value	Will panic if could not convert v to T
from_value_opt	Will return Err(v) if could not convert v to T

Type Definitions

Result