Crate mysql_async

mysql-async

Tokio based asynchronous MySql client library for rust progrumming language.

Installation

Library hosted on crates.io.

[dependencies]
mysql = "<desired version>"

Example

extern crate futures;
#[macro_use]
extern crate mysql_async as my;
extern crate tokio_core as tokio;
// ...

use futures::Future;
use my::prelude::*;
use tokio::reactor::Core;

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

fn main() {
    let mut lp = Core::new().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 pool = my::Pool::new(DATABASE_URL, &lp.handle());
    let future = pool.get_conn().and_then(|conn| {
        // Create temporary table
        conn.query(
            r"CREATE TEMPORARY TABLE payment (
                customer_id int not null,
                amount int not null,
                account_name text
            )"
        ).and_then(|result| result.drop_result())
    }).and_then(|conn| {
        // Save payments
        let params = payments.iter().map(|payment| {
            params! {
                "customer_id" => payment.customer_id,
                "amount" => payment.amount,
                "account_name" => payment.account_name.clone(),
            }
        }).collect();

        conn.batch_exec(r"INSERT INTO payment (customer_id, amount, account_name)
                        VALUES (:customer_id, :amount, :account_name)", params)
    }).and_then(|conn| {
        // Load payments from database.
        conn.prep_exec("SELECT customer_id, amount, account_name FROM payment", ())
    }).and_then(|result| {
        // Collect payments
        result.map(|row| {
            let (customer_id, amount, account_name) = my::from_row(row);
            Payment {
                customer_id: customer_id,
                amount: amount,
                account_name: account_name,
            }
        })
    }).and_then(|(payments, _ /* conn */)| {
        // Destructor of connection will return it to the pool
        // But pool should be disconnected explicitly because it is
        // asynchronous procedure.
        pool.disconnect().map(|_| payments)
    });

    let loaded_payments = lp.run(future).unwrap();

    assert_eq!(loaded_payments, payments);
}

Reexports

pub extern crate chrono;

pub extern crate either;

pub extern crate time;

Modules

consts	Mysql constants
futures	Futures used in this crate
prelude	Traits used in this crate

Macros

params

This macro allows you to pass named params to a prepared statement.

Structs

BinQueryResult	Uncollected result of a statement execution.
BinaryResult	Binary protocol result (i.e. statement execution result).
Column	Mysql column.
Conn	Mysql connection
ErrPacket	MySql error packet.
Error	The Error type.
Opts	Mysql connection options.
OptsBuilder	Provides a way to build Opts.
Pool	Asynchronous pool of MySql connections.
ResultSet	Result set of a query or statement execution.
Row	Row of a result set.
Serialized	Use it to pass T: Encodable as JSON to a prepared statement.
Stmt	Prepared MySql statement.
TextQueryResult	Uncollected result of a query execution.
TextResult	Text protocol result (i.e. query execution result).
TransBinQueryResult	It is like BinQueryResult for transactions.
TransTextQueryResult	It is like TextQueryResult for transactions.
Transaction	Wrapper for in-transaction connection.
Unserialized	Use it to parse T: Decodable from Value.
WhiteListFsLocalInfileHandler	Handles local infile requests from filesystem using explicit path white list.

Enums

ErrorKind	The kind of an error.
Params	Parameters of a statement.
Value	Value of a MySql column.

Traits

ResultExt

Additional methods for Result, for easy interaction with this crate.

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

Convenient wrapper around std::Result.