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 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]
version = "*"
default-features = false
features = ["socket"]
Windows support (since 0.18.0)
Currently rust-mysql-simple has no support for SSL on Windows.
[dependencies.mysql]
version = "*"
default-features = false
features = ["pipe"]
Optional features
You can compile rust-mysql-simple with the uuid
feature, which makes it possible to use UUIDs with MySQL conveniently.
The uuid
feature depends on the uuid
crate and UUIDs are assumed to be binary encoded in MySQL. So make sure that your MySQL fields are binary(16).
To activate the uuid
feature, add it to the features
list:
[dependencies]
mysql = { version = "*", features = ["uuid"] }
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 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 |
Macros
params |
Structs
Column |
Mysql
|
Conn |
Mysql connection. |
MySqlError | |
Opts |
Mysql connection options. |
OptsBuilder |
Provides a way to build |
Pool |
|
PooledConn |
Pooled mysql connection which will return to the pool on |
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 |
|
Traits
ConvIr |
Basic operations on |
FromRow |
Trait to convert |
FromValue |
Implement this trait to convert value to something. |
ToValue |
Functions
from_row |
Will panic if could not convert |
from_row_opt |
Will return |
from_value |
Will panic if could not convert |
from_value_opt |
Will return |
Type Definitions
Result |