mysql_async for WebAssembly

Tokio based asynchronous MySql client library for The Rust Programming Language. This is a fork from the original mysql_async with support for WebAssembly compilation target. That allows async MySql apps to run inside the WasmEdge Runtime as a lightweight and secure alternative to natively compiled apps in Linux container.

For more details and usage examples, please see the upstream mysql_async source and this example.

Note: We do not yet support SSL / TLS connections to databases in this WebAssembly client.

Installation

toml [dependencies] mysql_async_wasi = "<desired version>"

Example

```rust use mysql_async::prelude::*;

[derive(Debug, PartialEq, Eq, Clone)]

struct Payment { customerid: i32, amount: i32, accountname: Option, }

[tokio::main]

async fn main() -> Result<()> { let payments = vec![ Payment { customerid: 1, amount: 2, accountname: None }, Payment { customerid: 3, amount: 4, accountname: Some("foo".into()) }, Payment { customerid: 5, amount: 6, accountname: None }, Payment { customerid: 7, amount: 8, accountname: None }, Payment { customerid: 9, amount: 10, accountname: Some("bar".into()) }, ];

let database_url = /* ... */
# get_opts();

let pool = mysql_async::Pool::new(database_url);
let mut conn = pool.get_conn().await?;

// Create a temporary table
r"CREATE TEMPORARY TABLE payment (
    customer_id int not null,
    amount int not null,
    account_name text
)".ignore(&mut conn).await?;

// Save payments
r"INSERT INTO payment (customer_id, amount, account_name)
  VALUES (:customer_id, :amount, :account_name)"
    .with(payments.iter().map(|payment| params! {
        "customer_id" => payment.customer_id,
        "amount" => payment.amount,
        "account_name" => payment.account_name.as_ref(),
    }))
    .batch(&mut conn)
    .await?;

// Load payments from the database. Type inference will work here.
let loaded_payments = "SELECT customer_id, amount, account_name FROM payment"
    .with(())
    .map(&mut conn, |(customer_id, amount, account_name)| Payment { customer_id, amount, account_name })
    .await?;

// Dropped connection will go to the pool
drop(conn);

// The Pool must be disconnected explicitly because
// it's an asynchronous operation.
pool.disconnect().await?;

assert_eq!(loaded_payments, payments);

// the async fn returns Result, so
Ok(())

} ```

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.