Sqlx

https://docs.rs/sqlx/latest/sqlx/
Admin
Sqlx is an asynchronous SQL toolkit for Rust, providing database drivers for MySQL, PostgreSQL, and...
Tokens:2,120,950
Snippets:23,700
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());
```

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

### 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");
```

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

### 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());
```

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

### 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));
}
```

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

### 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"]
```

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

### 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);
}
```

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

### floor_char_boundary method example

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

Example usage of the floor_char_boundary method.

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.floor_char_boundary(13);
assert_eq!(closest, 10);
assert_eq!(&s[..closest], "❤️🧡");
```

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

### 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
```

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

### Example for partition_point

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

Example usage of the partition_point method, which returns the index of the first element of the second partition according to a predicate. The example finds the partition point for elements less than 5.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);
```

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

### 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);
```

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

### options

Source: https://docs.rs/sqlx/latest/sqlx/postgres/struct.PgConnectOptions.html?search=

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`

### Parameters
- **options** (`I`) - Required - An iterator of key-value pairs, where `K: Display` and `V: Display`.

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

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

### 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());
```

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

### 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")]);
```
```

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

### 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);
```

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

### 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}");
}
```

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

### 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 = ?
```

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

### 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": {} }));
```

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

### begin_with

Source: https://docs.rs/sqlx/latest/sqlx/postgres/type.PgPool.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 new transaction or an error.
```

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

### 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]);
```

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

### flatten() Examples for Result<Result<T, E>, E>

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

Examples for the flatten() method that converts Result<Result<T, E>, E> to Result<T, E>. Includes examples showing flattening one level and multiple levels.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### 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
```

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

### get_ssl_mode example

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

Returns the SSL mode as PgSslMode. The example creates default options and asserts the getter returns PgSslMode::Prefer.

```rust
let options = PgConnectOptions::new();
assert!(matches!(options.get_ssl_mode(), PgSslMode::Prefer));
```

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

### 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);
```

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

### 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.
```

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

### 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);
```

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

### install_default_drivers

Source: https://docs.rs/sqlx/latest/sqlx/any/index.html

Installs all currently compiled-in drivers for `AnyConnection` to use. This is the recommended way to activate all available drivers.

```APIDOC
## install_default_drivers

### Description
Installs all currently compiled-in drivers for `AnyConnection` to use. This is the recommended way to activate all available drivers.

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

### Usage
Call this function before using `AnyConnection` or `AnyPool` to ensure all compiled-in drivers are available.

### Example
```rust
sqlx::any::install_default_drivers();
```

### Notes
- This function is only available with the `any` crate feature.
- Without calling this or `install_drivers`, any use of `AnyConnection` or `AnyPool` will panic.
```

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

### 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]);
```

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

### get_port example

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

Returns the server's port as a u16. The example sets the port to 6543 and asserts the getter returns that value.

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

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

### 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_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);
```

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

### 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()`.
```

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

### 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());
```

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

### 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_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']]);
```

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

### 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");
```

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

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

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

### 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));
```

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

### 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")]);
```

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

### 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);
```

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

### 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);
```

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

### 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());
```

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

### 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.
```

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

### 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());
```

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

### 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());
```

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

### 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");
```

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

### connect_with

Source: https://docs.rs/sqlx/latest/sqlx/prelude/trait.Connection.html?search=u32+-%3E+bool

Establishes a new database connection using the provided options.

```APIDOC
## connect_with

### Description
Establish a new database connection with the provided options.

### 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 used to establish the connection.

### Returns
- `impl Future<Output = Result<Self, Error>>` - A future resolving to a new connection or an error.
```

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

### Get host with MySqlConnectOptions::get_host

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

Example for the get_host method. Creates a MySqlConnectOptions with host "127.0.0.1" and asserts that get_host returns that value.

```rust
let options = MySqlConnectOptions::new()
    .host("127.0.0.1");
assert_eq!(options.get_host(), "127.0.0.1");
```

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

### install_drivers

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

Installs a list of drivers for AnyConnection to use. The drivers must be specified explicitly, and any use of AnyConnection or AnyPool without this will panic.

```APIDOC
## install_drivers

### Description
Installs the list of drivers for `AnyConnection` to use. The drivers must be specified explicitly, and any use of `AnyConnection` or `AnyPool` without this will panic.

### Function Signature
`pub fn install_drivers(drivers: &[AnyDriver])`

### Parameters
- **drivers** (slice of `AnyDriver`) - Required - The list of drivers to install.

### Usage
Call this function before using `AnyConnection` or `AnyPool` to avoid panics.

### Notes
- This function is part of the `any` module.
- It is only available when the crate feature `any` is enabled.

```

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

### install_drivers

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

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

```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.
```

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

### impl<T> RangeBounds<T> for PgRange<T>

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

Implements the RangeBounds trait for PgRange<T>, providing methods to get start and end bounds, check containment, and check emptiness.

```APIDOC
## impl<T> RangeBounds<T> for PgRange<T>

### Description
Implements the RangeBounds trait for PgRange<T>, providing methods to get start and end bounds, check containment, and check emptiness.

### Methods

#### fn start_bound(&self) -> Bound<&T>
Returns the start bound of the range.

#### fn end_bound(&self) -> Bound<&T>
Returns the end bound of the range.

#### fn contains<U>(&self, item: &U) -> bool where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized
Returns `true` if `item` is contained in the range.

#### fn is_empty(&self) -> bool where T: PartialOrd
Returns `true` if the range contains no items. One-sided ranges (`RangeFrom`, etc) always return `false`.

```

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

### RangeBounds<T> for PgRange<T>

Source: https://docs.rs/sqlx/latest/sqlx/postgres/types/struct.PgRange.html?search=u32+-%3E+bool

Implements the RangeBounds trait for PgRange<T>, providing methods to get the start and end bounds, check containment, and check if the range is empty.

```APIDOC
## RangeBounds<T> for PgRange<T>

### Description
Implements the `RangeBounds<T>` trait for `PgRange<T>`, providing methods to get the start and end bounds, check if an item is contained, and check if the range is empty.

### Methods

#### fn start_bound(&self) -> Bound<&T>
Returns the start bound of the range.

#### fn end_bound(&self) -> Bound<&T>
Returns the end bound of the range.

#### fn contains<U>(&self, item: &U) -> bool
where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized
Returns `true` if `item` is contained in the range.

#### fn is_empty(&self) -> bool
where T: PartialOrd
Returns `true` if the range contains no items. One-sided ranges always return `false`.
```

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

### 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.
```

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

### iter example

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

Iterates over the entries of the map in sorted key order, printing each key-value pair. Also demonstrates using next() to get the first entry.

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

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{key}: {value}");
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));
```

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

### as_number: Get Number from JSON value

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

Returns the associated Number if the Value is a Number, otherwise None. Example shows converting integers and floats, and that a string is not a number.

```rust
let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" });

assert_eq!(v["a"].as_number(), Some(&Number::from(1u64)));
assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap()));
assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64)));

// The string `"4"` is not a number.
assert_eq!(v["d"].as_number(), None);
```

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

### 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:?}");
```

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

### as_array: Get array from JSON value

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

Returns the associated vector if the Value is an Array, otherwise None. Example shows checking length of an array and that an object is not an array.

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

// The length of `["an", "array"]` is 2 elements.
assert_eq!(v["a"].as_array().unwrap().len(), 2);

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

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

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

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

### install_drivers

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

Installs the list of drivers for `AnyConnection` to use. Must be called before an `AnyConnection` or `AnyPool` can be connected. Returns an error if called more than once.

```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 Type
- `Result<(), Box<dyn Error + Send + Sync>>` - Returns `Ok(())` on success, or an error if called more than once.

### Errors
- Returns an error if called more than once.

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

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

### starts_with example: check if slice starts with a prefix

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

Returns true if needle is a prefix of the slice or equal to the slice. Always returns true if needle is an empty slice.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

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

### install_drivers

Source: https://docs.rs/sqlx/latest/sqlx/any/fn.install_drivers.html?search=

Installs the list of drivers for `AnyConnection` to use. Must be called before an `AnyConnection` or `AnyPool` can be connected. Returns an error if called more than once.

```APIDOC
## install_drivers

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

### Function 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 Type
- `Result<(), Box<dyn Error + Send + Sync>>` - Returns `Ok(())` on success, or an error if called more than once.

### Errors
- Returns an error if called more than once.

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

```

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

### rsplitn example: split slice from the end into at most n subslices

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

Splits the slice at elements matching the predicate, starting from the end and working backwards, limited to at most n items. The matched element is not included. The last element contains the remainder. This example prints groups [50] and [10, 40, 30, 20].

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### Index into a JSON value with square brackets

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

Examples of using square brackets to index into a JSON value. Returns Value::Null in cases where get would return None.

```rust
let object = json!({
    "A": ["a", "á", "à"],
    "B": ["b", "b́"],
    "C": ["c", "ć", "ć̣", "ḉ"],
});
assert_eq!(object["B"][0], json!("b"));

assert_eq!(object["D"], json!(null));
assert_eq!(object[0]["x"]["y"]["z"], json!(null));
```

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

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

Source: https://docs.rs/sqlx/latest/sqlx/sqlite/struct.SqliteConnection.html

Establishes a new database connection with the provided options.

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

### Description
Establishes a new database connection with the provided options.

### Method
Rust method

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

### Parameters
- `options` (&Self::Options) - Required - The connection options.

### Returns
A future that resolves to `Result<Self, Error>`.
```

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

### and_then: chaining fallible operations

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

Shows how to use and_then to chain operations that may fail. The first example uses a function that squares and converts to string, returning an error on overflow. The second example uses metadata().and_then() to get file modification times, demonstrating error handling with ErrorKind::NotFound.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### install_default_drivers

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

Installs all currently compiled-in drivers for AnyConnection to use. This is the recommended way to activate all available drivers.

```APIDOC
## install_default_drivers

### Description
Installs all currently compiled-in drivers for `AnyConnection` to use. This is the recommended way to activate all available drivers.

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

### Usage
Call this function before using `AnyConnection` or `AnyPool` to avoid panics.

### Notes
- This function is part of the `any` module.
- It is only available when the crate feature `any` is enabled.

```

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

### get() example

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

Returns a reference to an element or subslice depending on the type of index. If given a position, returns the element or None if out of bounds. If given a range, returns the subslice or None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### install_default_drivers

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

Installs all currently compiled-in drivers for AnyConnection to use. This is the recommended way to activate all available drivers.

```APIDOC
## Function: install_default_drivers

### Description
Installs all currently compiled-in drivers for `AnyConnection` to use. This is the recommended way to activate all available drivers.

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

### Usage
Call this function before using `AnyConnection` or `AnyPool` to ensure drivers are available.

### Notes
- This function is part of the `any` crate feature.
- It is recommended to call this function before any database operations.

```

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

### as_str: Get string slice from JSON value

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

Returns the associated str if the Value is a String, otherwise None. Example shows extracting a string and printing it in JSON vs Rust representation.

```rust
let v = json!({ "a": "some string", "b": false });

assert_eq!(v["a"].as_str(), Some("some string"));

// The boolean `false` is not a string.
assert_eq!(v["b"].as_str(), None);

// JSON values are printed in JSON representation, so strings are in quotes.
//
//    The value is: "some string"
println!("The value is: {}", v["a"]);

// Rust strings are printed without quotes.
//
//    The value is: some string
println!("The value is: {}", v["a"].as_str().unwrap());
```

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

### Environment variables for multi-database project

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

Example .env file defining the database URLs for the foo and bar crates.

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