SQLx

https://docs.rs/sqlx/latest/
Admin
SQLx is an asynchronous, pure Rust SQL toolkit for building safe and performant applications.
Tokens:2,147,190
Snippets:15,915
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### get method example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgCiText.html

Example usage of the get method.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());
```

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

### Multi-database project configuration example

Source: https://docs.rs/sqlx/latest/sqlx/_config/common/struct.Config.html?search=std%3A%3Avec

Example showing how to configure multiple databases in a workspace by using different environment variables for each crate. Includes foo/sqlx.toml, bar/sqlx.toml, and .env files.

```toml
[common]
database-url-var = "FOO_DATABASE_URL"
```

```toml
[common]
database-url-var = "BAR_DATABASE_URL"
```

```env
FOO_DATABASE_URL=postgres://postgres@localhost:5432/foo
BAR_DATABASE_URL=postgres://postgres@localhost:5432/bar
```

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

### options

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Set additional startup options for the connection as a list of key-value pairs.

```APIDOC
## options

### Description
Set additional startup options for the connection as a list of key-value pairs. Escapes the options' backslash and space characters as per the PostgreSQL documentation.

### Method
`pub fn options<K, V, I>(self, options: I) -> PgConnectOptions where K: Display, V: Display, I: IntoIterator<Item = (K, V)>`

### Parameters
- **options** (`I`) - Required - An iterator of key-value pairs representing the startup options.

### Returns
`PgConnectOptions` - The updated connection options.

### Example
```rust
let options = PgConnectOptions::new()
    .options([("geqo", "off"), ("statement_timeout", "5min")]);
```
```

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

### Vec::len example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgArgumentBuffer.html

Returns the number of elements in the vector. The example shows getting the length of a vector.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### BTreeMap::range example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgHstore.html

Constructs a double-ended iterator over a sub-range of elements. The example uses a range with Included bounds and also shows the range syntax with a half-open range. Panics if start > end or if start == end with both bounds Excluded.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());
```

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

### Rust Example: Connecting with PgConnectOptions

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html?search=std%3A%3Avec

Demonstrates connecting to Postgres using URL strings, manually constructed options, and parsed options with logging. Requires sqlx with postgres feature and a runtime.

```rust
use sqlx::{Connection, ConnectOptions};
use sqlx::postgres::{PgConnectOptions, PgConnection, PgPool, PgSslMode};

// URL connection string
let conn = PgConnection::connect("postgres://localhost/mydb").await?;

// Manually-constructed options
let conn = PgConnectOptions::new()
    .host("secret-host")
    .port(2525)
    .username("secret-user")
    .password("secret-password")
    .ssl_mode(PgSslMode::Require)
    .connect()
    .await?;

// Modifying options parsed from a string
let mut opts: PgConnectOptions = "postgres://localhost/mydb".parse()?;

// Change the log verbosity level for queries.
// Information about SQL queries is logged at `DEBUG` level by default.
opts = opts.log_statements(log::LevelFilter::Trace);

let pool = PgPool::connect_with(opts).await?;
```

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

### Get a JSON object as a map

Source: https://docs.rs/sqlx/latest/sqlx/types/enum.JsonValue.html

Example of using the as_object method to get the associated Map if the Value is an Object. Returns None otherwise.

```rust
let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });

// The length of `{"nested": true}` is 1 entry.
assert_eq!(v["a"].as_object().unwrap().len(), 1);

// The array `["an", "array"]` is not an object.
assert_eq!(v["b"].as_object(), None);
```

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

### Example: connecting with MySqlConnectOptions

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Shows three ways to use MySqlConnectOptions: URL connection, manual construction, and modifying parsed options. The example uses log_statements to change log verbosity and MySqlPool::connect_with.

```rust
use sqlx::{Connection, ConnectOptions};
use sqlx::mysql::{MySqlConnectOptions, MySqlConnection, MySqlPool, MySqlSslMode};

// URL connection string
let conn = MySqlConnection::connect("mysql://root:password@localhost/db").await?;

// Manually-constructed options
let conn = MySqlConnectOptions::new()
    .host("localhost")
    .username("root")
    .password("password")
    .database("db")
    .connect().await?;

// Modifying options parsed from a string
let mut opts: MySqlConnectOptions = "mysql://root:password@localhost/db".parse()?;

// Change the log verbosity level for queries.
// Information about SQL queries is logged at `DEBUG` level by default.
opts = opts.log_statements(log::LevelFilter::Trace);

let pool = MySqlPool::connect_with(opts).await?;
```

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

### SQL file example for query_file!

Source: https://docs.rs/sqlx/latest/sqlx/macro.query_file.html

Example SQL file (examples/queries/account-by-id.sql) that the query_file! macro reads. The file path must be relative to the project root.

```sql
select * from (select (1) as id, 'Herp Derpinson' as name) accounts
where id = ?
```

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

### BTreeMap::range_mut example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgHstore.html

Constructs a mutable double-ended iterator over a sub-range of elements. The example modifies balances for keys in the range "B".."Cheryl" and then prints the map. Panics if start > end or if start == end with both bounds Excluded.

```rust
use std::collections::BTreeMap;

let mut map: BTreeMap<&str, i32> =
    [("Alice", 0), ("Bob", 0), ("Carol", 0), ("Cheryl", 0)].into();
for (_, balance) in map.range_mut("B".."Cheryl") {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{name} => {balance}");
}
```

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

### begin_with

Source: https://docs.rs/sqlx/latest/sqlx/sqlite/type.SqlitePool.html

Retrieves a connection and immediately begins a new transaction using the provided statement.

```APIDOC
## begin_with

### Description
Retrieves a connection and immediately begins a new transaction using the provided statement.

### Method
async fn begin_with(&self, statement: impl SqlSafeStr) -> Result<Transaction<'static, DB>, Error>

### Parameters
- **statement** (impl SqlSafeStr) - Required - The SQL statement to begin the transaction with.

### Returns
- **Result<Transaction<'static, DB>, Error>** - A transaction object on success, or an error.
```

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

### Get a mutable JSON object as a map

Source: https://docs.rs/sqlx/latest/sqlx/types/enum.JsonValue.html

Example of using the as_object_mut method to get the associated mutable Map if the Value is an Object. Returns None otherwise.

```rust
let mut v = json!({ "a": { "nested": true } });

v["a"].as_object_mut().unwrap().clear();
assert_eq!(v, json!({ "a": {} }));
```

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

### Example connection URLs for AnyConnectOptions

Source: https://docs.rs/sqlx/latest/sqlx/any/struct.AnyConnectOptions.html?search=

Example connection URLs that can be used to construct `AnyConnectOptions` via parsing. These show the format for PostgreSQL and MySQL databases.

```text
postgres://postgres:password@localhost/database
mysql://root:password@localhost/database
```

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

### rchunks_mut Example

Source: https://docs.rs/sqlx/latest/sqlx/sqlite/struct.SqliteOwnedBuf.html?search=

Demonstrates iterating over mutable chunks of a slice starting from the end.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

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

### Trim start matches example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgLTreeLabel.html

Demonstrates using trim_start_matches with a slice of characters.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

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

### begin

Source: https://docs.rs/sqlx/latest/sqlx/type.SqlitePool.html

Retrieves a connection and immediately begins a new transaction.

```APIDOC
## begin

### Description
Retrieves a connection and immediately begins a new transaction.

### Method
begin

### Signature
`pub async fn begin(&self) -> Result<Transaction<'static, DB>, Error>`

### Returns
- `Result<Transaction<'static, DB>, Error>` - A new transaction or an error.
```

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

### Index into a JSON value with get

Source: https://docs.rs/sqlx/latest/sqlx/types/enum.JsonValue.html

Examples of using the get method to index into a JSON array or map. Returns None if the index type does not match or the key/index is out of bounds.

```rust
let object = json!({ "A": 65, "B": 66, "C": 67 });
assert_eq!(*object.get("A").unwrap(), json!(65));

let array = json!([ "A", "B", "C" ]);
assert_eq!(*array.get(2).unwrap(), json!("C"));

assert_eq!(array.get("A"), None);
```

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

### BTreeMap::entry example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgHstore.html

Gets the given key's corresponding entry for in-place manipulation. The example counts occurrences of letters in a vector using and_modify and or_insert.

```rust
use std::collections::BTreeMap;

let mut count: BTreeMap<&str, usize> = BTreeMap::new();

// count the number of occurrences of letters in the vec
for x in ["a", "b", "a", "c", "a", "b"] {
    count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);
}

assert_eq!(count["a"], 3);
assert_eq!(count["b"], 2);
assert_eq!(count["c"], 1);
```

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

### begin_with

Source: https://docs.rs/sqlx/latest/sqlx/mysql/type.MySqlPool.html

Starts a new transaction using a custom SQL statement.

```APIDOC
## begin_with

### Description
Retrieves a connection and immediately begins a new transaction using the provided SQL statement.

### Method
begin_with

### Signature
`pub async fn begin_with(&self, statement: impl SqlSafeStr) -> Result<Transaction<'static, DB>, Error>`

### Parameters
- **statement** (impl SqlSafeStr) - Required - The SQL statement to begin the transaction with.

### Returns
- `Result<Transaction<'static, DB>, Error>` - A transaction if successful, otherwise an error.
```

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

### as_rchunks_mut Example

Source: https://docs.rs/sqlx/latest/sqlx/sqlite/struct.SqliteOwnedBuf.html?search=

Demonstrates splitting a mutable slice into N-element arrays starting from the end.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);
```

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

### pub async fn connect_with(options: <<DB as Database>::Connection as Connection>::Options) -> Result<Pool<DB>, Error>

Source: https://docs.rs/sqlx/latest/sqlx/type.AnyPool.html

Creates a new connection pool with default configuration and the given ConnectOptions, immediately establishing one connection.

```APIDOC
## pub async fn connect_with(options: <<DB as Database>::Connection as Connection>::Options) -> Result<Pool<DB>, Error>

### Description
Creates a new connection pool with a default pool configuration and the given `ConnectOptions`, and immediately establishes one connection.

### Method
async function

### Signature
`pub async fn connect_with(options: <<DB as Database>::Connection as Connection>::Options) -> Result<Pool<DB>, Error>`

### Parameters
- **options** (`<<DB as Database>::Connection as Connection>::Options`) - Required - The connection options for the specific database driver.

### Returns
- `Result<Pool<DB>, Error>` - A new pool with one established connection, or an error.

### Notes
- The default configuration is suited for testing and light-duty applications. For production, consider tweaking `PoolOptions::new()`.
```

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

### try_begin_with

Source: https://docs.rs/sqlx/latest/sqlx/self/struct.Pool.html?search=

Documentation for the `try_begin_with` method on `Pool`.

```APIDOC
## try_begin_with

### Description
Attempts to retrieve a connection and, if successful, immediately begins a new transaction using the provided SQL statement.

### Method
async fn

### Signature
`pub async fn try_begin_with(&self, statement: impl SqlSafeStr) -> Result<Option<Transaction<'static, DB>>, Error>`

### Parameters
- **statement** (impl SqlSafeStr) - Required - The SQL statement to begin the transaction with.

### Returns
- `Result<Option<Transaction<'static, DB>>, Error>` - `Ok(Some(transaction))` if a connection was acquired and the transaction started, `Ok(None)` if no connection was available, or `Err` if an error occurred.
```

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

### as_mut example

Source: https://docs.rs/sqlx/latest/sqlx/self/type.Result.html

Shows how to use as_mut to get mutable references to the Ok or Err values and modify them.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### get method example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgLTreeLabel.html

Returns a subslice of the string, returning None if the index is out of bounds or not on a UTF-8 boundary.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### Apply test fixtures with #[sqlx::test(fixtures(...))]

Source: https://docs.rs/sqlx/latest/sqlx/attr.test.html?search=std%3A%3Avec

Use the `fixtures` attribute on `#[sqlx::test]` to apply SQL fixture files before a test. The example uses the shorthand form `fixtures("users", "posts")` which resolves to `./fixtures/users.sql` and `./fixtures/posts.sql`; commented alternatives show explicit file paths and the `path`/`scripts` mode. Fixtures are applied in the given order, each as a single command string wrapped in an implicit `BEGIN` and `COMMIT`, so order them to satisfy foreign key constraints.

```rust
use sqlx::PgPool;
use serde_json::json;

// Alternatives:
// #[sqlx::test(fixtures("./fixtures/users.sql", "./fixtures/posts.sql"))]
// or
// #[sqlx::test(fixtures(path = "./fixtures", scripts("users", "posts")))]
#[sqlx::test(fixtures("users", "posts"))]
async fn test_create_comment(pool: PgPool) -> sqlx::Result<()> {
    // See examples/postgres/social-axum-with-tests for a more in-depth example. 
    let mut app = create_app(pool);     
    
    let comment = test_request(
        &mut app, "POST", "/v1/comment", json! { "postId": "1234" }
    ).await?;
    
    assert_eq!(comment["postId"], "1234");
    
    Ok(())
}
```

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

### as_rchunks example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgArgumentBuffer.html

Splits a slice into N-element arrays starting from the end, with a remainder at the beginning. The example shows a slice of length 5 with N=2, yielding a remainder of length 1 and chunks. Panics if N is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

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

### Set additional startup options with options

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html?search=std%3A%3Avec

Sets additional startup options for the connection as a list of key-value pairs. Escapes backslash and space characters as per the libpq documentation.

```rust
let options = PgConnectOptions::new()
    .options([("geqo", "off"), ("statement_timeout", "5min")]);
```

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

### sqlx.toml: create-schemas example

Source: https://docs.rs/sqlx/latest/sqlx/_config/migrate/struct.Config.html

Example `sqlx.toml` configuration for the `create-schemas` field. Specifies schemas to create before checking the migrations table.

```toml
[migrate]
create-schemas = ["foo"]
```

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

### Get charset with MySqlConnectOptions::get_charset

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_charset method. Creates a default MySqlConnectOptions and asserts that the charset is "utf8mb4".

```rust
let options = MySqlConnectOptions::new();
assert_eq!(options.get_charset(), "utf8mb4");
```

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

### install_default_drivers

Source: https://docs.rs/sqlx/latest/sqlx/any/fn.install_default_drivers.html?search=std%3A%3Avec

Documentation for the `install_default_drivers` function in the `sqlx::any` module.

```APIDOC
## Function install_default_drivers

### Description
Installs all currently compiled-in drivers for `AnyConnection` to use. May be called multiple times; only the first call will install drivers, subsequent calls will have no effect.

### Signature
```rust
pub fn install_default_drivers()
```

### Availability
Available on **crate feature `any`** only.

### Panics
Panics if `install_drivers` has already been called _not_ through this function.

### Usage
Call this function to register all compiled-in drivers for `AnyConnection` before using it.
```

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

### Get SSL mode with MySqlConnectOptions::get_ssl_mode

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_ssl_mode method. Creates a default MySqlConnectOptions and asserts that the SSL mode is Preferred.

```rust
let options = MySqlConnectOptions::new();
assert!(matches!(options.get_ssl_mode(), MySqlSslMode::Preferred));
```

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

### Get port with MySqlConnectOptions::get_port

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_port method. Creates a MySqlConnectOptions with port 6543 and asserts that get_port returns that value.

```rust
let options = MySqlConnectOptions::new()
    .port(6543);
assert_eq!(options.get_port(), 6543);
```

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

### install_drivers

Source: https://docs.rs/sqlx/latest/sqlx/any/fn.install_drivers.html?search=u32+-%3E+bool

Documentation for the `install_drivers` function in the `sqlx::any` module, which installs drivers for `AnyConnection`.

```APIDOC
## Function: install_drivers

### Description
Installs the list of drivers for `AnyConnection` to use. Must be called before an `AnyConnection` or `AnyPool` can be connected.

### Signature
```rust
pub fn install_drivers(
    drivers: &'static [AnyDriver],
) -> Result<(), Box<dyn Error + Send + Sync>>
```

### Parameters
- **drivers** (`&'static [AnyDriver]`) - Required - The list of drivers to install.

### Return Value
- `Result<(), Box<dyn Error + Send + Sync>>` - Returns `Ok(())` on success, or an error if called more than once.

### Errors
- If called more than once.
```

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

### get_database example

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html?search=std%3A%3Avec

Returns the current database name as Option<&str>. The example sets the database to "postgres" and asserts the getter returns Some.

```rust
let options = PgConnectOptions::new()
    .database("postgres");
assert!(options.get_database().is_some());
```

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

### iter example: iterate over slice items

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgArgumentBuffer.html

Shows how to iterate over a slice using the iter method, yielding all items from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### connect_with

Source: https://docs.rs/sqlx/latest/sqlx/prelude/trait.Connection.html?search=

Establishes a new database connection using the provided options object.

```APIDOC
## connect_with

### Description
Establishes a new database connection using the provided options object.

### Method
connect_with

### Signature
```rust
fn connect_with(options: &Self::Options) -> impl Future<Output = Result<Self, Error>> + Send
where Self: Sized
```

### Parameters
- **options** (Self::Options) - Required - The options object used to configure the connection.

### Returns
A Future that resolves to `Result<Self, Error>` where `Self` is the connection type.
```

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

### Get collation with MySqlConnectOptions::get_collation

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_collation method. Creates a MySqlConnectOptions with collation "collation" and asserts that get_collation returns Some.

```rust
let options = MySqlConnectOptions::new()
    .collation("collation");
assert!(options.get_collation().is_some());
```

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

### Box::into_raw Examples

Source: https://docs.rs/sqlx/latest/sqlx/_config/drivers/type.TryParseError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples demonstrating how to consume a Box and return a raw pointer.

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{dealloc, Layout};
use std::ptr;

let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    ptr::drop_in_place(ptr);
    dealloc(ptr as *mut u8, Layout::new::<String>());
}
```

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    drop(Box::from_raw(ptr));
}
```

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

### Get database with MySqlConnectOptions::get_database

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_database method. Creates a MySqlConnectOptions with database "postgres" and asserts that get_database returns Some.

```rust
let options = MySqlConnectOptions::new()
    .database("postgres");
assert!(options.get_database().is_some());
```

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

### Example: Using Text<SocketAddr> with MySQL

Source: https://docs.rs/sqlx/latest/sqlx/types/struct.Text.html?search=

Shows how to store and retrieve a `SocketAddr` as `TEXT` in MySQL using `Text<SocketAddr>`. Includes a `CREATE TABLE` comment and uses `sqlx::query` and `query_as`.

```rust
use std::net::SocketAddr;

use sqlx::Connection;
use sqlx::mysql::MySqlConnection;
use sqlx::types::Text;

use uuid::Uuid;
use time::OffsetDateTime;

#[derive(sqlx::FromRow, Debug)]
struct Login {
    user_id: Uuid,
    socket_addr: Text<SocketAddr>,
    login_at: OffsetDateTime
}


let mut conn: MySqlConnection = MySqlConnection::connect("<DATABASE URL>").await?;

let user_id: Uuid = "e9a72cdc-d907-48d6-a488-c64a91fd063c".parse().unwrap();
let socket_addr: SocketAddr = "198.51.100.47:31790".parse().unwrap();

// CREATE TABLE user_login(user_id VARCHAR(36), socket_addr TEXT, login_at TIMESTAMP);
sqlx::query("INSERT INTO user_login(user_id, socket_addr, login_at) VALUES (?, ?, NOW())")
    .bind(user_id)
    .bind(Text(socket_addr))
    .execute(&mut conn)
    .await?;

let logins: Vec<Login> = sqlx::query_as("SELECT * FROM user_login")
    .fetch_all(&mut conn)
    .await?;

println!("Logins for user ID {user_id}: {logins:?}");
```

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

### Get socket with MySqlConnectOptions::get_socket

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_socket method. Creates a MySqlConnectOptions with socket "/tmp" and asserts that get_socket returns Some.

```rust
let options = MySqlConnectOptions::new()
    .socket("/tmp");
assert!(options.get_socket().is_some());
```

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

### Multi-database project configuration for foo crate

Source: https://docs.rs/sqlx/latest/sqlx/_config/common/struct.Config.html?search=u32+-%3E+bool

Example configuration for the foo crate in a multi-database project, setting the database URL variable to FOO_DATABASE_URL.

```toml
[common]
database-url-var = "FOO_DATABASE_URL"
```

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

### Get username with MySqlConnectOptions::get_username

Source: https://docs.rs/sqlx/latest/sqlx/mysql/struct.MySqlConnectOptions.html

Example for the get_username method. Creates a MySqlConnectOptions with username "foo" and asserts that get_username returns that value.

```rust
let options = MySqlConnectOptions::new()
    .username("foo");
assert_eq!(options.get_username(), "foo");
```

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

### Box::from_raw Examples

Source: https://docs.rs/sqlx/latest/sqlx/_config/drivers/type.TryParseError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples demonstrating how to reconstruct a Box from a raw pointer.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```
Tokens:
Raw