Crate mysql [] [src]

rust-mysql-simple

Mysql client library implemented in rust.

Install

Please use mysql crate:

[dependencies]
mysql = "*"

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

[dependencies.mysql]
version = "*"
features = ["ssl"]

Windows support (since 0.18.0)

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

Example

#[macro_use]
extern crate mysql;
// ...

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
                                       (: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.
            stmt.execute(params!{
                "customer_id" => p.customer_id,
                "amount" => p.amount,
                "account_name" => &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 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`
        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!");
}

Reexports

pub extern crate time;
pub extern crate uuid;
pub extern crate chrono;
pub extern crate serde;
pub extern crate serde_json;

Modules

conn
consts
error
prelude
value

Macros

params

Structs

Column

Mysql Column.

Conn

Mysql connection.

Deserialized

Use it to parse T: Decodable from Value.

LocalInfile

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.

LocalInfileHandler

Callback to handle requests for local files. Consult Mysql documentation for the format of local infile data.

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.

Serialized

Use it to pass T: Encodable as JSON to a prepared statement.

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.

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