[][src]Crate mysql

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() {
    // 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)
                                   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 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| {
            // ⚠️ 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);
    println!("Yay!");
}

Re-exports

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

Modules

consts
error
prelude

Macros

params

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

Structs

Column

Represents MySql Column (column packet).

Conn

Mysql connection.

Deserialized

Use it to parse T: Deserialize from Value.

FromRowError

FromRow conversion error.

FromValueError

FromValue conversion error.

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

Client side representation of a MySql row.

Serialized

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

Stmt

Mysql prepared statement.

Transaction

Enums

DriverError
Error
IsolationLevel
Params

Representations of parameters of a prepared statement.

ServerError

Server error codes (u16)

UrlError
Value

Client side representation of a value of MySql column.

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(FromValueError(v)) if could not convert v to T

Type Definitions

Result