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>"

Crate Features

Default feature set is wide – it includes all default mysql_common features as well as native-tls-based TLS support.

List Of Features

• minimal – enables only necessary features (at the moment the only necessary feature is flate2 backend). Enables:

  • `flate2/zlib"

  Example:

  toml [dependencies] mysql_async = { version = "*", default-features = false, features = ["minimal"]}

  *Note: it is possible to use another flate2 backend by directly choosing it:

  toml [dependencies] mysql_async = { version = "*", default-features = false } flate2 = { version = "*", default-features = false, features = ["rust_backend"] }

• default – enables the following set of crate's and dependencies' features:

  • native-tls-tls
  • `flate2/zlib"
  • mysql_common/bigdecimal03
  • mysql_common/rust_decimal
  • mysql_common/time03
  • mysql_common/uuid
  • mysql_common/frunk

• default-rustls – same as default but with rustls-tls instead of native-tls-tls.

  Example:

  toml [dependencies] mysql_async = { version = "*", default-features = false, features = ["default-rustls"] }

• native-tls-tls – enables native-tls-based TLS support (conflicts with rustls-tls)

  Example:

  ```toml [dependencies] mysql_async = { version = "*", default-features = false, features = ["native-tls-tls"] }

• rustls-tls – enables native-tls-based TLS support (conflicts with native-tls-tls)

  Example:

  ```toml [dependencies] mysql_async = { version = "*", default-features = false, features = ["rustls-tls"] }

TLS/SSL Support

SSL support comes in two flavors:

1. Based on native-tls – this is the default option, that usually works without pitfalls (see the native-tls-tls crate feature).

2. Based on rustls – TLS backend written in Rust (see the rustls-tls crate feature).

   Please also note a few things about rustls:

   • it will fail if you'll try to connect to the server by its IP address, hostname is required;
   • it, most likely, won't work on windows, at least with default server certs, generated by the MySql installer.

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

• Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)

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.