mysql_async

https://docs.rs/mysql_async
Admin
Tokio based asynchronous MySQL client library for Rust with support for connection pooling, prepared...
Tokens:320,311
Snippets:2,924
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Run Setup Commands

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Executes setup commands upon connection. Processes a list of setup queries.

```rust
async fn run_setup_commands(&mut self) -> Result<()> {
        let mut setup = self.inner.opts.setup().to_vec();

        while let Some(query) = setup.pop() {
            self.query_drop(query).await?;
        }

        Ok(())
    }
```

--------------------------------

### Basic Connection Example

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/lib.rs.html

A basic example demonstrating how to establish a connection and perform a query using mysql_async.

```rust
use mysql_async::prelude::*
use mysql_async::{Result, test_misc::get_opts};
use std::env;
```

--------------------------------

### Executing Initial and Setup Commands

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Runs a sequence of commands after establishing the connection, including initial setup and any user-defined setup commands. This ensures the connection is ready for use.

```rust
conn.read_settings().await?;
conn.reconnect_via_socket_if_needed().await?;
conn.run_init_commands().await?;
conn.run_setup_commands().await?;
```

--------------------------------

### Setting Setup Queries

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.OptsBuilder.html

Defines a list of SQL queries to be executed as part of the connection setup process.

```rust
pub fn setup<T: Into<String>>(self, setup: Vec<T>) -> Self
```

--------------------------------

### init

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Gets the list of SQL commands to be executed once a new connection is established. These commands are useful for setting session variables or performing initial setup on the database side.

```APIDOC
## init

### Description
Gets the list of SQL commands to be executed once a new connection is established. These commands are useful for setting session variables or performing initial setup on the database side.

### Method
`pub fn init(&self) -> &[String]`

### Returns
A slice of strings, where each string is an SQL command to be executed.
```

--------------------------------

### Execute Setup Queries on Connection Reset and User Change

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Demonstrates the use of `setup` queries, which are executed on initial connection, after a `reset`, and after a `change_user` operation. This ensures that session state is consistently maintained across these operations.

```rust
    #[tokio::test]
    async fn should_execute_setup_queries_on_reset() -> super::Result<()> {
        let opts = OptsBuilder::from_opts(get_opts()).setup(vec!["SET @a = 42", "SET @b = 'foo'"]);
        let mut conn = Conn::new(opts).await?;

        // initial run
        let mut result: Vec<(u8, String)> = conn.query("SELECT @a, @b").await?;
        assert_eq!(result, vec![(42, "foo".into())]);

        // after reset
        if conn.reset().await? {
            result = conn.query("SELECT @a, @b").await?;
            assert_eq!(result, vec![(42, "foo".into())]);
        }

        // after change user
        conn.change_user(Default::default()).await?;
        result = conn.query("SELECT @a, @b").await?;
        assert_eq!(result, vec![(42, "foo".into())]);

        conn.disconnect().await?;
        Ok(())
    }
```

--------------------------------

### Native TLS Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with the 'minimal' feature and TLS support via the native-tls backend.

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

--------------------------------

### Minimal Feature Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with the 'minimal' feature to enable only necessary components, including the flate2 zlib backend.

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

--------------------------------

### Default Features Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with default features enabled, which includes the flate2 zlib backend and derive support.

```toml
[dependencies]
mysql_async = { version = "*", features = ["tracing"] }
```

--------------------------------

### Transaction Management: Commit and Rollback

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Demonstrates starting, committing, and rolling back SQL transactions. Use this to ensure data integrity by grouping multiple operations into atomic units. Includes examples of implicit rollback via `drop`.

```rust
async fn should_run_transactions() -> super::Result<()> {
        let mut conn = Conn::new(get_opts()).await?;
        conn.query_drop("CREATE TEMPORARY TABLE tmp (id INT, name TEXT)")
            .await?;
        let mut transaction = conn.start_transaction(Default::default()).await?;
        transaction
            .query_drop("INSERT INTO tmp VALUES (1, 'foo'), (2, 'bar')")
            .await?;
        assert_eq!(transaction.last_insert_id(), None);
        assert_eq!(transaction.affected_rows(), 2);
        assert_eq!(transaction.get_warnings(), 0);
        assert_eq!(transaction.info(), "Records: 2  Duplicates: 0  Warnings: 0");
        transaction.commit().await?;
        let output_opt = conn.query_first("SELECT COUNT(*) FROM tmp").await?;
        assert_eq!(output_opt, Some((2u8,)));
        let mut transaction = conn.start_transaction(Default::default()).await?;
        transaction
            .query_drop("INSERT INTO tmp VALUES (3, 'baz'), (4, 'quux')")
            .await?;
        let output_opt = transaction
            .exec_first("SELECT COUNT(*) FROM tmp", ()) 
            .await?;
        assert_eq!(output_opt, Some((4u8,)));
        transaction.rollback().await?;
        let output_opt = conn.query_first("SELECT COUNT(*) FROM tmp").await?;
        assert_eq!(output_opt, Some((2u8,)));

        let mut transaction = conn.start_transaction(Default::default()).await?;
        transaction
            .query_drop("INSERT INTO tmp VALUES (3, 'baz')")
            .await?;
        drop(transaction); // implicit rollback
        let output_opt = conn.query_first("SELECT COUNT(*) FROM tmp").await?;
        assert_eq!(output_opt, Some((2u8,)));

        conn.disconnect().await?;
        Ok(())
    }
```

--------------------------------

### Start a Transaction

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/pool/mod.rs.html

Initiates a new database transaction with specified options. It first acquires a connection from the pool and then starts the transaction.

```rust
pub async fn start_transaction(&self, options: TxOpts) -> Result<Transaction<'static>>
    {
        let conn = self.get_conn().await?;
        Transaction::new(conn, options).await
    }
```

--------------------------------

### Rustls TLS with Ring Provider Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with the 'minimal-rust' feature, rustls TLS backend, and the ring provider.

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

--------------------------------

### Start Transaction

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Conn.html

Asynchronously starts a new transaction with the specified options. Returns a `Result<Transaction<'_>>`.

```rust
pub async fn start_transaction( &mut self, options: TxOpts, ) -> Result<Transaction<'_>>
```

--------------------------------

### OptsBuilder::setup

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Provides a list of SQL queries to be executed during the connection setup phase. These queries are run before the connection is considered ready for use.

```APIDOC
## OptsBuilder::setup

### Description
Sets a list of SQL queries to execute during connection setup.

### Method
`setup<T: Into<String>>(mut self, setup: Vec<T>) -> Self`

### Parameters
* `setup` (Vec<String>): A vector of SQL query strings for connection setup.
```

--------------------------------

### Execute a Query and Get First Row

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/pool/mod.rs.html

Demonstrates how to get a connection from the pool, execute a query with parameters, and retrieve the first resulting row. This is useful for simple select operations where only one row is expected.

```Rust
async fn op(pool: &Pool) {
            let _: Option<Row> = pool
                .get_conn()
                .await
                .unwrap()
                .exec_first("SELECT ?, ?", (42, "foo"))
                .await
                .unwrap();
        }
```

--------------------------------

### Default Rustls Ring TLS Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with default features and TLS support via rustls using the ring provider.

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

--------------------------------

### Default Rustls TLS Installation

Source: https://docs.rs/mysql_async/0.37.0/index.html

Install mysql_async with default features and TLS support via rustls using the aws-lc-rs provider.

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

--------------------------------

### Connection by Ref Example

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Connection.html

Demonstrates how to use `connection.by_ref()` to borrow a connection for query execution, allowing subsequent queries on the same connection object.

```rust
async fn connection_by_ref(mut connection: Connection<'_, '_>) {
    // Perform some query
    "SELECT 1".ignore(connection.by_ref()).await.unwrap();
    // Perform another query.
    // We can only do this because we used `by_ref` earlier.
    "SELECT 2".ignore(connection).await.unwrap();
}
```

--------------------------------

### Get GnoInterval Start

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.GnoInterval.html

Returns the inclusive start value of the GnoInterval.

```rust
pub fn start(&self) -> u64
```

--------------------------------

### Using OptsBuilder with Default and From

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Demonstrates creating and modifying connection options using OptsBuilder. Shows how to set host, database name, and port.

```rust
# use mysql_async::OptsBuilder;
# // You can use the default builder
# let existing_opts = OptsBuilder::default()
#     .ip_or_hostname("foo")
#     .db_name(Some("bar"))
#     // ..
# ;
# 
# // Or use existing T: Into<Opts>
# let builder = OptsBuilder::from(existing_opts)
#     .ip_or_hostname("baz")
#     .tcp_port(33306)
#     // ..
# ;

```

--------------------------------

### Create Empty StmtBulkExecuteFlags

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtBulkExecuteFlags.html

Get a flags value with all bits unset. Use this to start with no flags set.

```rust
pub const fn empty() -> StmtBulkExecuteFlags
```

--------------------------------

### Get Connection Options

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Conn.html

Returns a reference to the connection options used for this connection.

```rust
pub fn opts(&self) -> &Opts
```

--------------------------------

### Create All-Set StmtBulkExecuteFlags

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtBulkExecuteFlags.html

Get a flags value with all known bits set. Use this to start with all flags enabled.

```rust
pub const fn all() -> StmtBulkExecuteFlags
```

--------------------------------

### Get an empty StmtExecuteParamFlags

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtExecuteParamFlags.html

Creates a new StmtExecuteParamFlags with all bits unset. Useful for starting with a clean set of flags.

```rust
pub const fn empty() -> StmtExecuteParamFlags
```

--------------------------------

### Minimal Rust Backend Feature Configuration

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/lib.rs.html

Use the 'minimal-rust' feature for a minimal setup with a Rust-based compression backend.

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

--------------------------------

### Opts::setup

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Retrieves commands to be executed on new connections and after resets or user changes.

```APIDOC
## Opts::setup

### Description
Retrieves commands to be executed on new connection and every time `Conn::reset` or `Conn::change_user` is invoked.

### Method
`pub fn setup(&self) -> &[String]`

### Parameters
None

### Response
#### Success Response (&[String])
- **&[String]**: A slice of strings, where each string is a command to execute.
```

--------------------------------

### Creating and Configuring TxOpts

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.TxOpts.html

Demonstrates how to create a default TxOpts instance and configure it with a consistent snapshot and a specific isolation level.

```rust
let tx_opts = TxOpts::default()
    .with_consistent_snapshot(true)
    .with_isolation_level(IsolationLevel::RepeatableRead);
```

--------------------------------

### Get Type ID

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Schema.html

Gets the TypeId of the Schema instance. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId

```

--------------------------------

### Conn::start_transaction

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/queryable/transaction.rs.html

Starts a new transaction on the given connection with specified options. This is the primary method for initiating a transaction.

```APIDOC
## Conn::start_transaction

### Description
Starts a transaction on the connection.

### Method
`async fn start_transaction(&mut self, options: TxOpts) -> Result<Transaction<'_>>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
# use mysql_async::prelude::*;
# use mysql_async::{Conn, TxOpts};
# async fn example(conn: &mut Conn) -> mysql_async::Result<()>
# {
let tx_opts = TxOpts::default().with_consistent_snapshot(true);
let mut transaction = conn.start_transaction(tx_opts).await?;
// Use the transaction object here...
// transaction.commit().await?;
# Ok(())
# }
```

### Response
#### Success Response
- **Transaction<'_>** (Transaction) - A new transaction object that can be used to execute queries within the transaction scope.

#### Response Example
```json
// Success is indicated by returning a Transaction object.
// Errors are returned as mysql_async::Error.
```

### Error Handling
- **DriverError::NestedTransaction**: If a transaction is already in progress on the connection.
```

--------------------------------

### Connect and Query Plugins

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Establishes a connection, pings the server, and retrieves a list of available plugins. This is a basic connection and introspection test.

```rust
async fn should_connect() -> super::Result<()>
{
    let mut conn: Conn = Conn::new(get_opts()).await?;
    conn.ping().await?;
    let plugins: Vec<String> = conn
        .query_map("SHOW PLUGINS", |mut row: crate::Row| {
            row.take("Name").unwrap()
        })
        .await?;

    // Should connect with any combination of supported plugin and empty-nonempty password.
    let variants = vec![
        ("caching_sha2_password", 2_u8, "non-empty"),
        ("caching_sha2_password", 2_u8, ""),
        ("mysql_native_password", 0_u8, "non-empty"),
        ("mysql_native_password", 0_u8, ""),
    ]
    .into_iter()
    .filter(|variant| plugins.iter().any(|p| p == variant.0));

    for (plug, val, pass) in variants {
        dbg!((plug, val, pass, conn.inner.version));

        if plug == "mysql_native_password" && conn.inner.version >= (8, 4, 0) {
            continue;
        }

        let _ = conn.query_drop("DROP USER 'test_user'@'%'`).await;

        let query = format!("CREATE USER 'test_user'@'%' IDENTIFIED WITH {}", plug);
        conn.query_drop(query).await.unwrap();

        if conn.inner.version < (8, 0, 11) {
            conn.query_drop(format!("SET old_passwords = {}", val))
                .await
                .unwrap();
            conn.query_drop(format!(
                "SET PASSWORD FOR 'test_user'@'%' = PASSWORD('{}')",
                pass
            ))
            .await
            .unwrap();
        } else {

```

--------------------------------

### Setup Stream TCP Options

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Sets TCP options for the connection's I/O stream, such as TCP_NODELAY. Requires the stream to be present.

```rust
fn setup_stream(&mut self) -> Result<()>
{
    debug_assert!(self.inner.stream.is_some());
    if let Some(stream) = self.inner.stream.as_mut() {
        stream.set_tcp_nodelay(self.inner.opts.tcp_nodelay())?;
    }
    Ok(())
}
```

--------------------------------

### Executing Text and Binary Protocol Queries

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/prelude/trait.Query.html

Demonstrates how to execute both text-based SQL queries and prepared statements (binary protocol) using the `first` method. Requires importing `mysql_async::prelude::*`.

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

// Assuming get_opts() is defined elsewhere and returns PoolOptions
// let pool = Pool::new(get_opts());

// text protocol query
// let num: Option<u32> = "SELECT 42".first(&pool).await?;
// assert_eq!(num, Some(42));

// binary protocol query (prepared statement)
// let row: Option<(u32, String)> = "SELECT ?, ?".with((42, "foo")).first(&pool).await?;
// assert_eq!(row.unwrap(), (42, "foo".into()));

```

--------------------------------

### Initialize WhiteListFsHandler with OptsBuilder

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.WhiteListFsHandler.html

Demonstrates how to configure mysql_async's OptsBuilder to use a WhiteListFsHandler. This example shows setting up a whitelist for a specific local infile text file.

```rust
use mysql_async::{OptsBuilder, WhiteListFsHandler};

let mut opts = OptsBuilder::from_opts(database_url);
opts.local_infile_handler(Some(WhiteListFsHandler::new(
    &["path/to/local_infile.txt"][..],
)));
```

--------------------------------

### Configure SslOpts with Client Identity (native-tls)

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Example of creating SslOpts with a client identity for native-tls. Requires the 'native-tls-tls' feature.

```rust
#[cfg(feature = "native-tls-tls")]
let ssl_opts = SslOpts::default()
    .with_client_identity(Some(ClientIdentity::new(Path::new("/path").into())
        .with_password("******")
    ));
```

--------------------------------

### Execute Initialization Queries on New Connection

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Demonstrates how to provide initialization queries that are executed when a new MySQL connection is established. These queries are useful for setting up session variables or performing initial configurations.

```rust
    #[tokio::test]
    async fn should_execute_init_queries_on_new_connection() -> super::Result<()> {
        let opts = OptsBuilder::from_opts(get_opts()).init(vec!["SET @a = 42", "SET @b = 'foo'"]);
        let mut conn = Conn::new(opts).await?;
        let result: Vec<(u8, String)> = conn.query("SELECT @a, @b").await?;
        conn.disconnect().await?;
        assert_eq!(result, vec![(42, "foo".into())]);
        Ok(())
    }
```

--------------------------------

### Start a MySQL Transaction

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/queryable/transaction.rs.html

Initiates a new transaction on a given connection with specified options. Ensure the connection is not already in a transaction.

```rust
pub async fn start_transaction(&mut self, options: TxOpts) -> Result<Transaction<'_>> {
        Transaction::new(self, options).await
    }
```

--------------------------------

### Start Transaction

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Pool.html

Asynchronously starts a new transaction with specified options. This function returns a Future that resolves to a `Transaction` on success.

```rust
pub async fn start_transaction(
    &self,
    options: TxOpts,
) -> Result<Transaction<'static>>
```

--------------------------------

### Opts::init

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Retrieves commands to be executed once a new connection is established.

```APIDOC
## Opts::init

### Description
Retrieves commands to be executed once a new connection is established.

### Method
`pub fn init(&self) -> &[String]`

### Parameters
None

### Response
#### Success Response (&[String])
- **&[String]**: A slice of strings, where each string is a command to execute.
```

--------------------------------

### setup

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Retrieves SQL commands to be executed on new connections and also upon resetting or changing the user of an existing connection. This is useful for ensuring a consistent session state across connection lifecycle events.

```APIDOC
## setup

### Description
Retrieves SQL commands to be executed on new connections and also upon resetting or changing the user of an existing connection. This is useful for ensuring a consistent session state across connection lifecycle events.

### Method
`pub fn setup(&self) -> &[String]`

### Returns
A slice of strings, where each string is an SQL command to be executed during connection setup or reset.
```

--------------------------------

### Get TypeId of ColumnType

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/enum.ColumnType.html

Implements the Any trait, providing a way to get the TypeId of a ColumnType instance. This is useful for dynamic type checking.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Building MySQL Options with OptsBuilder

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Demonstrates how to incrementally build MySQL connection options using OptsBuilder, setting user, password, and database name.

```rust
let mut builder = OptsBuilder::from_opts(opts.clone());

        if let Some(user) = self.user {
            builder = builder.user(user);
        }

        if let Some(pass) = self.pass {
            builder = builder.pass(pass);
        }

        if let Some(db_name) = self.db_name {
            builder = builder.db_name(db_name);
        }

        *opts = Opts::from(builder);
```

--------------------------------

### Get Underlying Bits of StmtBulkExecuteFlags

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtBulkExecuteFlags.html

Get the underlying bits value of the flags. The returned value is exactly the bits set in this flags value.

```rust
pub const fn bits(&self) -> u16
```

--------------------------------

### MySQL Async Query Example

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/query.rs.html

Demonstrates executing both text protocol queries and binary protocol queries (prepared statements) using the `mysql_async` crate. Requires a running MySQL instance and the `tokio` runtime.

```rust
# use mysql_async::test_misc::get_opts;
# #[tokio::main]
# async fn main() -> mysql_async::Result<()> {
use mysql_async::prelude::*;
use mysql_async::Pool;
let pool = Pool::new(get_opts());

// text protocol query
let num: Option<u32> = "SELECT 42".first(&pool).await?;
assert_eq!(num, Some(42));

// binary protocol query (prepared statement)
let row: Option<(u32, String)> = "SELECT ?, ?".with((42, "foo")).first(&pool).await?;
assert_eq!(row.unwrap(), (42, "foo".into()));

# Ok(())
# }
```

--------------------------------

### Prepare and Close Statements

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Shows how to prepare SQL statements using different parameter styles (positional and named) and then close them. This example demonstrates preparing the same query multiple times.

```rust
let mut conn = Conn::new(get_opts()).await?;
let stmt = conn.prep(r"SELECT ?").await?;
conn.close(stmt).await?;
conn.disconnect().await?;

let mut conn = Conn::new(get_opts()).await?;
let stmt = conn.prep(r"SELECT :foo").await?;

{
    let query = String::from("SELECT ?, ?");
    let stmt = conn.prep(&*query).await?;
    conn.close(stmt).await?;
    {
        let mut conn = Conn::new(get_opts()).await?;
        let stmt = conn.prep(&*query).await?;
        conn.close(stmt).await?;
        conn.disconnect().await?;
    }
}

conn.close(stmt).await?;
conn.disconnect().await?;

Ok(())
}
```

--------------------------------

### Get StmtExecuteParamsFlags from Name

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtExecuteParamsFlags.html

Attempts to get a StmtExecuteParamsFlags value by its string name. Returns `None` if the name is empty or does not correspond to a known flag.

```rust
pub fn from_name(name: &str) -> Option<StmtExecuteParamsFlags>
```

--------------------------------

### Run Initialization Commands

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Executes initialization commands after connection. Includes running user-defined callbacks and initial queries.

```rust
async fn run_init_commands(&mut self) -> Result<()> {
        if let Some(callback) = self.inner.opts.after_connect() {
            callback(self).await?;
        }

        let mut init = self.inner.opts.init().to_vec();

        while let Some(query) = init.pop() {
            self.query_drop(query).await?;
        }

        Ok(())
    }
```

--------------------------------

### StmtCache Get by Query

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/stmt_cache.rs.html

Retrieves an `Entry` from the cache based on a query. It first looks up the query in the `query_map` to get the statement ID, then fetches the entry from the `cache`.

```rust
pub fn by_query<T>(&mut self, query: &T) -> Option<&Entry>
    where
        QueryString: Borrow<T>,
        QueryString: PartialEq<T>,
        T: Hash + Eq,
        T: ?Sized,
    {
        let id = self.query_map.get(query).cloned();
        match id {
            Some(id) => self.cache.get(&id),
            None => None,
        }
    }
```

--------------------------------

### Execute and Verify Queries

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Demonstrates executing a query, retrieving session status, and asserting the count of statement closes. It also shows how to inspect the statement cache order.

```rust
conn.exec_drop("DO 6", ()).await?;
let row_opt = conn
    .query_first("SHOW SESSION STATUS LIKE 'Com_stmt_close';")
    .await?;
let (_, count): (String, usize) = row_opt.unwrap();
assert_eq!(count, 3);
let order = conn
    .stmt_cache_ref()
    .iter()
    .map(|item| item.1.query.0.as_ref())
    .collect::<Vec<&[u8]>>();
assert_eq!(order, &[b"DO 6", b"DO 5", b"DO 3"]);
conn.disconnect().await?;
Ok(())
}
```

--------------------------------

### Get StmtBulkExecuteFlags from Name

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtBulkExecuteFlags.html

Get a flags value with the bits of a flag with the given name set. Returns `None` if the name is empty or doesn’t correspond to any named flag.

```rust
pub fn from_name(name: &str) -> Option<StmtBulkExecuteFlags>
```

--------------------------------

### OptsBuilder::init

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Provides a list of SQL queries to be executed immediately after establishing a connection. These queries are typically used for setting session-specific configurations.

```APIDOC
## OptsBuilder::init

### Description
Sets a list of SQL queries to execute upon establishing a connection.

### Method
`init<T: Into<String>>(mut self, init: Vec<T>) -> Self`

### Parameters
* `init` (Vec<String>): A vector of SQL query strings to execute.
```

--------------------------------

### type_id

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/consts/struct.StmtBulkExecuteFlags.html

Gets the `TypeId` of the `StmtBulkExecuteFlags`.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
- **self**: `&Self` - A reference to the flags.

### Returns
- `TypeId`: The `TypeId` of the flags.
```

--------------------------------

### Initialize WhiteListFsHandler with a list of allowed paths

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/local_infile_handler/builtin.rs.html

Demonstrates how to create a `WhiteListFsHandler` instance by providing an iterator of paths that will be allowed for `LOCAL INFILE` requests. This setup is crucial for security to prevent arbitrary file access.

```rust
use mysql_async::{OptsBuilder, WhiteListFsHandler};

# let database_url = "mysql://root:password@127.0.0.1:3307/mysql";
let mut opts = OptsBuilder::from_opts(database_url);
opts.local_infile_handler(Some(WhiteListFsHandler::new(
    &["path/to/local_infile.txt"][..],
)));

```

--------------------------------

### Setting up a Local INFILE Handler

Source: https://docs.rs/mysql_async

Demonstrates how to set up a one-time local infile handler for loading data into a temporary table. This handler provides data as a stream of Bytes. It also shows error handling for common LOAD DATA LOCAL issues.

```rust
let pool = mysql_async::Pool::new(database_url);

let mut conn = pool.get_conn().await?;
"CREATE TEMPORARY TABLE tmp (id INT, val TEXT)".ignore(&mut conn).await?;

// We are going to call `LOAD DATA LOCAL` so let's setup a one-time handler.
conn.set_infile_handler(async move {
    // We need to return a stream of `io::Result<Bytes>`
    Ok(stream::iter([Bytes::from("1,a\r\n"), Bytes::from("2,b\r\n3,c")]).map(Ok).boxed())
});

let result = r#"LOAD DATA LOCAL INFILE 'whatever'\n    INTO TABLE `tmp`\n    FIELDS TERMINATED BY ',' ENCLOSED BY '"'\n    LINES TERMINATED BY '\r\n'"#.ignore(&mut conn).await;

match result {
    Ok(())
    => (), // Success
    Err(Error::Server(ref err)) if err.code == 1148 => {
        // The used command is not allowed with this MySQL version
        return Ok(());
    },
    Err(Error::Server(ref err)) if err.code == 3948 => {
        // Loading local data is disabled;
        // this must be enabled on both the client and the server
        return Ok(());
    }
    e @ Err(_) => e.unwrap(),
}

// Now let's verify the result
let result: Vec<(u32, String)> = conn.query("SELECT * FROM tmp ORDER BY id ASC").await?;
assert_eq!(
    result,
    vec![(1, "a".into()), (2, "b".into()), (3, "c".into())]
);

drop(conn);
pool.disconnect().await?;
```

--------------------------------

### Opts::pool_opts

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Gets the connection pool options.

```APIDOC
## Opts::pool_opts

### Description
Gets the connection pool options. Defaults to `Default::default()`.

### Method
`pub fn pool_opts(&self) -> &PoolOpts`

### Parameters
None

### Response
#### Success Response (&PoolOpts)
- **&PoolOpts**: A reference to the `PoolOpts` struct.
```

--------------------------------

### Initializing ChangeUserOpts

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Shows how to create a new instance of ChangeUserOpts with default empty values for user, pass, and db_name.

```rust
pub fn new() -> Self {
        Self {
            user: None,
            pass: None,
            db_name: None,
        }
    }
```

--------------------------------

### Opts::conn_ttl

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Gets the connection time-to-live (TTL) for the pool.

```APIDOC
## Opts::conn_ttl

### Description
Gets the connection time-to-live (TTL) for the pool. The pool will close a connection if the time since its last I/O exceeds this duration. Defaults to the `wait_timeout` value. `None` resets to the default. Can be set using the `conn_ttl` URL parameter.

### Method
`pub fn conn_ttl(&self) -> Option<Duration>`

### Parameters
None

### Response
#### Success Response (Option<Duration>)
- **Option<Duration>**: An Option containing the connection TTL duration, or None if not set.
```

--------------------------------

### Create a new MySQL Async Pool

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/pool/mod.rs.html

Initializes a new connection pool with specified options. Panics if options conversion fails.

```rust
pub fn new<O>(opts: O) -> Pool
    where
        Opts: TryFrom<O>,
        <Opts as TryFrom<O>>::Error: std::error::Error,
    {
        let opts = Opts::try_from(opts).unwrap();
        let pool_opts = opts.pool_opts().clone();
        let metrics = Arc::new(Metrics::default());
        let (tx, rx) = mpsc::unbounded_channel();
        Pool {
            opts,
            inner: Arc::new(Inner {
                close: false.into(),
                closed: false.into(),
                metrics: metrics.clone(),
                exchange: Mutex::new(Exchange {
                    available: InPoolConnections::new(
                        pool_opts.constraints().max(),
                        metrics.clone(),
                    ),
                    waiting: Waitlist::new(metrics),
                    exist: 0,
                    recycler: Some((rx, pool_opts)),
                }),
            }),
            drop: tx,
        }
    }
```

--------------------------------

### Initializing OptsBuilder with Default Settings

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Creates a new OptsBuilder with default settings, including default host, port, and MysqlOpts.

```rust
impl Default for OptsBuilder {
    fn default() -> Self {
        let address = HostPortOrUrl::default();
        Self {
            opts: MysqlOpts::default(),
            ip_or_hostname: address.get_ip_or_hostname().into(),
            tcp_port: address.get_tcp_port(),
            resolved_ips: None,
        }
    }
}
```

--------------------------------

### Opts::tcp_keepalive

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Gets the TCP keep-alive timeout for the connection.

```APIDOC
## Opts::tcp_keepalive

### Description
Gets the TCP keep-alive timeout in milliseconds for the MySQL connection. Defaults to `None`. Can be set using the `tcp_keepalive` URL parameter.

### Method
`pub fn tcp_keepalive(&self) -> Option<Duration>`

### Parameters
None

### Response
#### Success Response (Option<Duration>)
- **Option<Duration>**: An Option containing the TCP keep-alive duration, or None if not set.
```

--------------------------------

### PoolOpts::reset_connection

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.PoolOpts.html

Gets the current setting for resetting connections.

```APIDOC
## PoolOpts::reset_connection

### Description

Returns the current value of the `reset_connection` setting, indicating whether connections are reset when returned to the pool.

### Method

```rust
pub fn reset_connection(&self) -> bool
```

### Returns

A boolean indicating if connections are reset (`true`) or not (`false`).
```

--------------------------------

### Execute Parameterized Binary Query with Multiple Result Sets

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/query.rs.html

Demonstrates running a parameterized SQL query using binary protocol. It shows how to bind parameters and then collect, ignore, fetch the first, fetch all, map, and reduce results. This is useful for queries with dynamic values.

```rust
macro_rules! query {
            (@static) => {
                "SELECT ?, ? UNION ALL SELECT ?, ?"
            };
            (@string) => {
                String::from("SELECT ?, ? UNION ALL SELECT ?, ?")
            };
            (@boxed) => {
                query!(@string).into_boxed_str()
            };
            (@arc) => {
                std::sync::Arc::<str>::from(query!(@boxed))
            };
        }

        let query_string = query!(@string);
        let params_static = ("1", "2", "3", "4");
        let params_string = (
            "1".to_owned(),
            "2".to_owned(),
            "3".to_owned(),
            "4".to_owned(),
        );

        macro_rules! test {
            ($query:expr, $params:expr, $conn:expr) => {{ // ... macro body ... }}
        }

        // Example usage with connection, transaction, and pool would follow here,
        // similar to the text query example but using parameterized queries.
```

```rust
async fn should_run_bin_query() -> Result<()> {
        // ... macro definitions and variable initializations ...

        macro_rules! test {
            ($query:expr, $params:expr, $conn:expr) => {{ 
                let query = { $query.with($params) };
                let mut result = query.run($conn).await?;
                let result1: Vec<(u8, u8)> = result.collect().await?;
                assert_eq!(result1, vec![(1, 2), (3, 4)]);

                $query.with($params).ignore($conn).await?;

                let result: Option<(u8, u8)> = $query.with($params).first($conn).await?;
                assert_eq!(result, Some((1, 2)));

                let result: Vec<(u8, u8)> = $query.with($params).fetch($conn).await?;
                assert_eq!(result, vec![(1, 2), (3, 4)]);

                let result = $query
                    .with($params)
                    .map($conn, |row: (u8, u8)| format!("{:?}", row))
                    .await?;
                assert_eq!(result, vec![String::from("(1, 2)"), String::from("(3, 4)")]);

                let result = $query
                    .with($params)
                    .reduce($conn, 0_u8, |acc, row: (u8, u8)| acc + row.0 + row.1)
                    .await?;
                assert_eq!(result, 10);

                $query
                    .with(vec![$params, $params, $params, $params])
                    .batch($conn)
            }};
        }
        // ... rest of the test function ...
        Ok(())
    }
```

--------------------------------

### Pool::start_transaction

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/pool/mod.rs.html

Starts a new transaction on a connection obtained from the pool.

```APIDOC
## Pool::start_transaction

### Description
Starts a new transaction using a connection from the pool.

### Arguments
* `options`: `TxOpts` specifying the transaction options.

### Returns
A `Result<Transaction<'static>>` which is `Ok(Transaction)` on success or `Err(Error)` on failure.
```

--------------------------------

### MySQL Connection and Query Execution

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Demonstrates establishing an asynchronous MySQL connection and executing basic queries, including setting and retrieving user-defined variables.

```rust
let mut conn = Conn::new(get_opts()).await?;

        assert_eq!(
            conn.query_first::<Value, _>("SELECT @foo").await?.unwrap(),
            Value::NULL
        );

        conn.query_drop("SET @foo = 'foo'").await?;

        assert_eq!(
            conn.query_first::<String, _>("SELECT @foo").await?.unwrap(),
            "foo",
        );
```

--------------------------------

### Opts::root_certs

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/opts/mod.rs.html

Gets the configured root certificates for certificate validation.

```APIDOC
## `root_certs`

### Description

Gets the configured root certificates used for validating the server's certificate.

### Method

`root_certs(&self) -> &[PathOrBuf<'static>]`

### Returns

`&[PathOrBuf<'static>]` - A slice of paths or buffers representing the root certificates.
```

--------------------------------

### Execute Static and Dynamic Queries with Connection

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/query.rs.html

Demonstrates executing different types of queries (static, string, boxed, arc) and prepared statements using a direct connection. Includes tests for both direct execution and within a transaction.

```rust
    let mut conn = Conn::new(get_opts()).await?;
    let statement = conn.prep(query!(@static)).await?;
    test!(query!(@static), params_static, &mut conn);
    test!(query!(@string), params_string.clone(), &mut conn);
    test!(query!(@boxed), params_string.clone(), &mut conn);
    test!(query!(@arc), params_string.clone(), &mut conn);
    test!(&query_string, params_string.clone(), &mut conn);
    test!(&statement, params_string.clone(), &mut conn);
    test!(statement.clone(), params_string.clone(), &mut conn);

    let mut tx = conn.start_transaction(Default::default()).await?;
    test!(query!(@static), params_string.clone(), &mut tx);
    test!(query!(@string), params_static, &mut tx);
    test!(&query_string, params_static, &mut tx);
    test!(&statement, params_string.clone(), &mut tx);
    test!(statement.clone(), params_string.clone(), &mut tx);
    tx.rollback().await?;

    conn.disconnect().await?;
```

--------------------------------

### Setting up a Local INFILE Handler

Source: https://docs.rs/mysql_async/0.37.0/index.html

Demonstrates how to set up a one-time local infile handler for loading data into a temporary table. This handler provides data in chunks and handles potential MySQL errors during the load process.

```rust
let pool = mysql_async::Pool::new(database_url);

let mut conn = pool.get_conn().await?;
"CREATE TEMPORARY TABLE tmp (id INT, val TEXT)".ignore(&mut conn).await?;

// We are going to call `LOAD DATA LOCAL` so let's setup a one-time handler.
conn.set_infile_handler(async move {
    // We need to return a stream of `io::Result<Bytes>`
    Ok(stream::iter([Bytes::from("1,a\r\n"), Bytes::from("2,b\r\n3,c")]).map(Ok).boxed())
});

let result = r#"LOAD DATA LOCAL INFILE 'whatever'\n    INTO TABLE `tmp`\n    FIELDS TERMINATED BY ',' ENCLOSED BY '"'\n    LINES TERMINATED BY '\r\n'"#.ignore(&mut conn).await;

match result {
    Ok(())
    => (),
    Err(Error::Server(ref err)) if err.code == 1148 => {
        // The used command is not allowed with this MySQL version
        return Ok(())
    },
    Err(Error::Server(ref err)) if err.code == 3948 => {
        // Loading local data is disabled;
        // this must be enabled on both the client and the server
        return Ok(())
    }
    e @ Err(_) => e.unwrap(),
}

// Now let's verify the result
let result: Vec<(u32, String)> = conn.query("SELECT * FROM tmp ORDER BY id ASC").await?;
assert_eq!(
    result,
    vec![(1, "a".into()), (2, "b".into()), (3, "c".into())]
);

drop(conn);
pool.disconnect().await?;
```

--------------------------------

### Get Transaction Status

Source: https://docs.rs/mysql_async/0.37.0/src/mysql_async/conn/mod.rs.html

Retrieves the current transaction status of the connection.

```rust
self.inner.tx_status
```

--------------------------------

### Setting Initial Queries

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.OptsBuilder.html

Specifies a list of SQL queries to be executed immediately after establishing a connection.

```rust
pub fn init<T: Into<String>>(self, init: Vec<T>) -> Self
```

--------------------------------

### Opts::abs_conn_ttl

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Gets the absolute connection time-to-live (TTL) for the pool.

```APIDOC
## Opts::abs_conn_ttl

### Description
Gets the absolute connection time-to-live (TTL) for the pool. The pool will close a connection when this absolute TTL has elapsed. Disabled by default. Enables forced recycling and migration of connections within a guaranteed timeframe. This TTL bypasses pool constraints and an idle pool can go below the min size. Can be set using the `abs_conn_ttl` URL parameter.

### Method
`pub fn abs_conn_ttl(&self) -> Option<Duration>`

### Parameters
None

### Response
#### Success Response (Option<Duration>)
- **Option<Duration>**: An Option containing the absolute connection TTL duration, or None if not set.
```

--------------------------------

### Get Sid UUID

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Sid.html

Retrieves the UUID associated with the Sid instance.

```rust
pub fn uuid(&self) -> [u8; 16]
```

--------------------------------

### Full MySQL Async CRUD Example

Source: https://docs.rs/mysql_async/0.37.0/index.html

This snippet demonstrates a complete asynchronous workflow for interacting with a MySQL database. It includes setting up a connection pool, creating a temporary table, inserting multiple records using batch operations, and then querying those records back into Rust structs. Ensure you have a database URL configured.

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

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

#[tokio::main]
async fn main() -> Result<()>
{
    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 database_url = /* ... */;

    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(())
}

```

--------------------------------

### PoolOpts::new

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.PoolOpts.html

Creates a new instance of PoolOpts with default settings.

```APIDOC
## PoolOpts::new

### Description

Creates a new instance of `PoolOpts` by calling `Self::default()`.

### Method

```rust
pub fn new() -> Self
```

### Returns

A new `PoolOpts` instance with default values.
```

--------------------------------

### Get GnoInterval End

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.GnoInterval.html

Returns the exclusive end value of the GnoInterval.

```rust
pub fn end(&self) -> u64
```

--------------------------------

### Setting up a Local INFILE Handler

Source: https://docs.rs/mysql_async/0.37.0/mysql_async

Demonstrates how to set up a one-time local infile handler for LOAD DATA LOCAL operations. This handler provides data as a stream of Bytes. It also shows error handling for common LOAD DATA LOCAL issues and verifies the data insertion.

```rust
let pool = mysql_async::Pool::new(database_url);

let mut conn = pool.get_conn().await?;
"CREATE TEMPORARY TABLE tmp (id INT, val TEXT)".ignore(&mut conn).await?;

// We are going to call `LOAD DATA LOCAL` so let's setup a one-time handler.
conn.set_infile_handler(async move {
    // We need to return a stream of `io::Result<Bytes>`
    Ok(stream::iter([Bytes::from("1,a\r\n"), Bytes::from("2,b\r\n3,c")]).map(Ok).boxed())
});

let result = r#"LOAD DATA LOCAL INFILE 'whatever'\n    INTO TABLE `tmp`\n    FIELDS TERMINATED BY ',' ENCLOSED BY '"'\n    LINES TERMINATED BY '\r\n'"#.ignore(&mut conn).await;

match result {
    Ok(())
    => (), 
    Err(Error::Server(ref err)) if err.code == 1148 => {
        // The used command is not allowed with this MySQL version
        return Ok(())
    },
    Err(Error::Server(ref err)) if err.code == 3948 => {
        // Loading local data is disabled;
        // this must be enabled on both the client and the server
        return Ok(())
    }
    e @ Err(_) => e.unwrap(),
}

// Now let's verify the result
let result: Vec<(u32, String)> = conn.query("SELECT * FROM tmp ORDER BY id ASC").await?;
assert_eq!(
    result,
    vec![(1, "a".into()), (2, "b".into()), (3, "c".into())]
);

drop(conn);
pool.disconnect().await?;
```

--------------------------------

### Opts::abs_conn_ttl_jitter

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Opts.html

Gets the jitter added to the absolute connection time-to-live (TTL).

```APIDOC
## Opts::abs_conn_ttl_jitter

### Description
Gets the upper bound of a random value added to the absolute TTL, if enabled. Disabled by default. Should be used to prevent connections from closing at the same time. Can be set using the `abs_conn_ttl_jitter` URL parameter.

### Method
`pub fn abs_conn_ttl_jitter(&self) -> Option<Duration>`

### Parameters
None

### Response
#### Success Response (Option<Duration>)
- **Option<Duration>**: An Option containing the absolute connection TTL jitter duration, or None if not set.
```

--------------------------------

### Get Sid Intervals

Source: https://docs.rs/mysql_async/0.37.0/mysql_async/struct.Sid.html

Retrieves the slice of GnoIntervals associated with the Sid instance.

```rust
pub fn intervals(&self) -> &[GnoInterval]
```
Tokens:
Raw