Expand description
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
Macros
This macro is a convenient way to pass named parameters to a statement.
Structs
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.Mysql
prepared statement.
Enums
Representations of parameters of a prepared statement.
Server error codes (u16)
Client side representation of a value of MySql column.
Functions
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