SeaORM

https://docs.rs/sea-orm/1.1.14/
Admin
SeaORM is an async and dynamic relational ORM for Rust that helps developers build web services with...
Tokens:1,007,707
Snippets:8,018
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### SeaORM Driver Proxy Example

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/driver/proxy.rs.html

A snippet showing the end of a database connection setup within SeaORM's driver proxy. It indicates the completion of an asynchronous operation.

```rust
None,
            None,
        )
        .await
    }
}
```

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

### Find All Entities Example

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/entity/base_entity.rs.html

Demonstrates how to find all entities of a specific type. This example shows a typical usage pattern for retrieving multiple records.

```rust
///     Some(cake::Model {
///         id: 1,
///         name: "New York Cheese".to_owned(),
///     })
/// );
///
/// assert_eq!(
///     cake::Entity::find().all(&db).await?,
///     [
///         cake::Model {
///             id: 1,
///             name: "New York Cheese".to_owned(),
///         },
///         cake::Model {
///             id: 2,
///             name: "Chocolate Forest".to_owned(),
///         },
///     ]
/// );
///
/// assert_eq!(
///     db.into_transaction_log(),
///     [
///         Transaction::from_sql_and_values(
///             DbBackend::Postgres,
///             r#"SELECT \"cake\".\"id\", \"cake\".\"name\" FROM \"cake\" LIMIT $1"#,
///             [1u64.into()]
///         ),
///         Transaction::from_sql_and_values(
///             DbBackend::Postgres,
///             r#"SELECT \"cake\".\"id\", \"cake\".\"name\" FROM \"cake\""#,
///             []
///         ),
///     ]
/// );
/// #
/// # Ok(())
/// # }
/// ```
/// fn find() -> Select<Self> {
///     Select::new()
/// }
```

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

### begin

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Starts a new database transaction.

```APIDOC
## begin

### Description
Initiates a new database transaction. This method is part of the `TransactionTrait`.

### Method
`async fn begin(&self) -> Result<DatabaseTransaction, DbErr>`

### Response
- `Ok(DatabaseTransaction)`: A new database transaction object.
- `Err(DbErr)`: If the transaction cannot be started.
```

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

### Example of NaiveDateTime creation with microseconds

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.ChronoDate.html

Demonstrates creating a NaiveDateTime with microseconds and asserting its properties. This example uses the deprecated `and_hms_micro` function.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime, Timelike, Weekday};

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();

let dt: NaiveDateTime = d.and_hms_micro_opt(12, 34, 56, 789_012).unwrap();
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);
```

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

### NaiveTime Default Value Example

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Time.html

Demonstrates how to get the default NaiveTime value, which is midnight (00:00:00).

```rust
use chrono::NaiveTime;

let default_time = NaiveTime::default();
assert_eq!(default_time, NaiveTime::from_hms_opt(0, 0, 0).unwrap());
```

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

### Initialize ConnectOptions

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mod.rs.html

Create new `ConnectOptions` for a database by passing in a URI string. This sets up the basic connection parameters.

```rust
pub fn new<T>(url: T) -> Self
where
    T: Into<String>,
{
    Self {
        url: url.into(),
        max_connections: None,
        min_connections: None,
        connect_timeout: None,
        idle_timeout: None,
        acquire_timeout: None,
        max_lifetime: None,
        sqlx_logging: true,
        sqlx_logging_level: log::LevelFilter::Info,
        sqlx_slow_statements_logging_level: log::LevelFilter::Off,
        sqlx_slow_statements_logging_threshold: Duration::from_secs(1),
        sqlcipher_key: None,
        schema_search_path: None,
        test_before_acquire: true,
        connect_lazy: false,
    }
}
```

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

### Create ConnectOptions from URI

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mod.rs.html

Initialize `ConnectOptions` by providing a database connection URI string. This is the primary way to configure connection settings.

```rust
impl<T>
From<T> for ConnectOptions
where
    T: Into<String>,
{
    fn from(s: T) -> ConnectOptions {
        ConnectOptions::new(s.into())
    }
}
```

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

### Get Weekday

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.TimeDate.html

Determine the day of the week for a given date. Examples cover various dates throughout the year.

```rust
assert_eq!(date!(2019-01-01).weekday(), Tuesday);
```

```rust
assert_eq!(date!(2019-02-01).weekday(), Friday);
```

```rust
assert_eq!(date!(2019-03-01).weekday(), Friday);
```

```rust
assert_eq!(date!(2019-04-01).weekday(), Monday);
```

```rust
assert_eq!(date!(2019-05-01).weekday(), Wednesday);
```

```rust
assert_eq!(date!(2019-06-01).weekday(), Saturday);
```

```rust
assert_eq!(date!(2019-07-01).weekday(), Monday);
```

```rust
assert_eq!(date!(2019-08-01).weekday(), Thursday);
```

```rust
assert_eq!(date!(2019-09-01).weekday(), Sunday);
```

```rust
assert_eq!(date!(2019-10-01).weekday(), Tuesday);
```

```rust
assert_eq!(date!(2019-11-01).weekday(), Friday);
```

```rust
assert_eq!(date!(2019-12-01).weekday(), Sunday);
```

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

### Get Day of Year (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Retrieves the day of the year, starting from 0. The value ranges from 0 to 365.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal0(), 250);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal0(), 73);
```

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

### begin_with_config

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Starts a new database transaction with custom configuration.

```APIDOC
## begin_with_config

### Description
Initiates a new database transaction with specific configuration options. This method is part of the `TransactionTrait`.

### Method
`async fn begin_with_config(&self, config: BeginTransactionConfig) -> Result<DatabaseTransaction, DbErr>`

### Parameters
- `config` (BeginTransactionConfig): Configuration options for the transaction.

### Response
- `Ok(DatabaseTransaction)`: A new database transaction object with the specified configuration.
- `Err(DbErr)`: If the transaction cannot be started with the given configuration.
```

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

### Get Day of Year (1-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Retrieves the day of the year, starting from 1. The value ranges from 1 to 366.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal(), 251);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal(), 74);
```

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

### begin

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.SqlxSqlitePoolConnection.html

Bundle a set of SQL statements that execute together.

```APIDOC
## begin

### Description
Bundle a set of SQL statements that execute together.

### Method
`async fn begin(&self, isolation_level: Option<IsolationLevel>, access_mode: Option<AccessMode>) -> Result<DatabaseTransaction, DbErr>`

### Parameters
- `isolation_level` (Option<IsolationLevel>): The isolation level for the transaction.
- `access_mode` (Option<AccessMode>): The access mode for the transaction.
```

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

### Get Day of Month (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Retrieves the day of the month, starting from 0. The value ranges from 0 to 30.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day0(), 7);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day0(), 13);
```

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

### Build and Execute a SELECT Query

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/entity/column.rs.html

Demonstrates building a SELECT query for the 'hello' table using `DbBackend::Postgres` and asserting its string representation.

```rust
assert_eq!(
    E::find().build(DbBackend::Postgres).to_string(),
    r#"SELECT "hello"."id", "hello"."one1", "hello"."two", "hello"."three3" FROM "hello""#,
);
```

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

### fn begin

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.ProxyDatabaseTrait.html

Initiates a new transaction in the proxy database.

```APIDOC
## fn begin<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,
Begin a transaction in the [ProxyDatabase]
```

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

### Getting Month0 from NaiveDate

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Retrieves the month component of a `NaiveDate`, starting from 0. The value ranges from 0 to 11.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().month0(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().month0(), 2);
```

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

### Connect to PostgreSQL with Options

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/driver/sqlx_postgres.rs.html

Establishes a connection to a PostgreSQL database using provided SeaORM ConnectOptions. Configures logging and search path based on the options.

```rust
pub async fn connect(options: ConnectOptions) -> Result<DatabaseConnection, DbErr> {
        let mut opt = options
            .url
            .parse::<PgConnectOptions>()
            .map_err(sqlx_error_to_conn_err)?;
        use sqlx::ConnectOptions;
        if !options.sqlx_logging {
            opt = opt.disable_statement_logging();
        } else {
            opt = opt.log_statements(options.sqlx_logging_level);
            if options.sqlx_slow_statements_logging_level != LevelFilter::Off {
                opt = opt.log_slow_statements(
                    options.sqlx_slow_statements_logging_level,
                    options.sqlx_slow_statements_logging_threshold,
                );
            }
        }
        let set_search_path_sql = options.schema_search_path.as_ref().map(|schema| {
            let mut string = "SET search_path = ".to_owned();
            if schema.starts_with('"') {
                write!(&mut string, "{schema}").unwrap();
            } else {
                for (i, schema) in schema.split(',').enumerate() {
                    if i > 0 {
                        write!(&mut string, ",").unwrap();
                    }
                    if schema.starts_with('"') {
                        write!(&mut string, "{schema}").unwrap();
                    } else {
                        write!(&mut string, "\"{schema}\"").unwrap();
                    }
                }
            }
            string
        });
        let lazy = options.connect_lazy;
        let mut pool_options = options.sqlx_pool_options();
        if let Some(sql) = set_search_path_sql {
            pool_options = pool_options.after_connect(move |conn, _| {
                let sql = sql.clone();
                Box::pin(async move {
                    sqlx::Executor::execute(conn, sql.as_str())
                        .await
                        .map(|_| ())
                })
            });
        }
        let pool = if lazy {
            pool_options.connect_lazy_with(opt)
        } else {
            pool_options
                .connect_with(opt)
                .await
                .map_err(sqlx_error_to_conn_err)?
        };
        Ok(DatabaseConnection::SqlxPostgresPoolConnection(
            SqlxPostgresPoolConnection {
                pool,
                metric_callback: None,
            },
        ))
    }
```

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

### Get Day of Year (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.ChronoDateTime.html

Extracts the day of the year, starting from 0. The valid range is 0 to 365.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime = NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
```

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

### Get Day of Year (1-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.ChronoDateTime.html

Extracts the day of the year, starting from 1. The valid range is 1 to 366.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime = NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

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

### Get Day of Month (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.ChronoDateTime.html

Extracts the day of the month, starting from 0. The valid range is 0 to 30.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime = NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
```

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

### Create ConnectOptions from URL

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Create new ConnectOptions for a Database by passing in a URI string.

```rust
pub fn new<T>(url: T) -> Self
where T: Into<String>,
```

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

### Get Day of Year (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.DateTime.html

Retrieves the day of the year, starting from 0. The valid range is 0 to 365.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
```

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

### begin_with_config

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.TransactionTrait.html

Starts a database transaction with specified isolation level and access mode. This method allows for finer control over transaction behavior.

```APIDOC
## begin_with_config

### Description
Execute SQL `BEGIN` transaction with isolation level and/or access mode. Returns a Transaction that can be committed or rolled back.

### Method
`begin_with_config`

### Parameters
- **isolation_level** (Option<IsolationLevel>) - Optional - The isolation level for the transaction.
- **access_mode** (Option<AccessMode>) - Optional - The access mode for the transaction.

### Returns
A `Future` that resolves to a `Result<DatabaseTransaction, DbErr>`.
```

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

### Get Day of Year (1-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.DateTime.html

Retrieves the day of the year, starting from 1. The valid range is 1 to 366.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

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

### Get Day of Month (0-indexed)

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.DateTime.html

Retrieves the day of the month, starting from 0. The valid range is 0 to 30.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
```

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

### Instantiate MockDatabase

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mock.rs.html

Create a mock database instance by specifying the DbBackend to simulate different SQL database behaviors. This is the starting point for setting up mock database interactions.

```rust
impl MockDatabase {
    /// Instantiate a mock database with a [DbBackend] to simulate real
    /// world SQL databases
    pub fn new(db_backend: DbBackend) -> Self {
        Self {
            db_backend,
            transaction: None,
            transaction_log: Vec::new(),
            exec_results: Vec::new(),
            query_results: Vec::new(),
        }
    }
// ... other methods
```

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

### begin

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.TransactionTrait.html

Executes the SQL `BEGIN` command to start a new database transaction. It returns a `DatabaseTransaction` object that can be committed or rolled back.

```APIDOC
## begin

### Description
Executes SQL `BEGIN` transaction. Returns a Transaction that can be committed or rolled back.

### Method
`begin`

### Parameters
None

### Returns
A `Future` that resolves to a `Result<DatabaseTransaction, DbErr>`.
```

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

### Get Monday-Based Week Number

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.TimeDateTime.html

Calculates the week number where week 1 starts on the first Monday. The value is between 0 and 53.

```rust
assert_eq!(datetime!(2019-01-01 0:00).monday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00).monday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00).monday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00).monday_based_week(), 0);
```

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

### Begin a Database Transaction with Configuration

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Initiates a new database transaction with specific configuration options. This allows for more control over the transaction's behavior.

```rust
async fn begin_with_config(
    &self,

```

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

### Get Sunday-Based Week Number

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.TimeDateTime.html

Calculates the week number where week 1 starts on the first Sunday. The value is between 0 and 53.

```rust
assert_eq!(datetime!(2019-01-01 0:00).sunday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00).sunday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00).sunday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00).sunday_based_week(), 0);
```

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

### BigDecimal as_bigint_and_exponent example

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.BigDecimal.html

Demonstrates how to get the internal representation of a BigDecimal as a BigInt and an exponent. A positive exponent signifies a negative power of 10.

```rust
use bigdecimal::{BigDecimal, num_bigint::BigInt};

let n: BigDecimal = "1.23456".parse().unwrap();
let expected = ("123456".parse::<BigInt>().unwrap(), 5);
assert_eq!(n.as_bigint_and_exponent(), expected);
```

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

### Begin Transaction with Configuration

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Starts a new database transaction with optional isolation level and access mode. This is useful when specific transaction settings are required.

```rust
async fn begin_with_config(
            &self,
            isolation_level: Option<IsolationLevel>,
            access_mode: Option<AccessMode>,
        ) -> Result<DatabaseTransaction, DbErr> {
            DatabaseTransaction::begin(
                Arc::clone(&self.conn),
                self.backend,
                self.metric_callback.clone(),
                isolation_level,
                access_mode,
            )
            .await
        }
```

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

### NaiveDateTime Datelike Month0 Example

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.ChronoDateTime.html

Illustrates how to get the month as a zero-based index (0-11) from a NaiveDateTime object using the `month0()` method from the `Datelike` trait.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month0(), 8);
```

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

### Example: Finding Models with EntityTrait

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/trait.EntityTrait.html

Demonstrates how to use the `find` method from EntityTrait to select one or all models from a table. Includes assertions for transaction logs.

```rust
use sea_orm::{entity::*, query::*, tests_cfg::cake};

assert_eq!(
    cake::Entity::find().one(&db).await?,
    Some(cake::Model {
        id: 1,
        name: "New York Cheese".to_owned(),
    })
);

assert_eq!(
    cake::Entity::find().all(&db).await?,
    [
        cake::Model {
            id: 1,
            name: "New York Cheese".to_owned(),
        },
        cake::Model {
            id: 2,
            name: "Chocolate Forest".to_owned(),
        },
    ]
);

assert_eq!(
    db.into_transaction_log(),
    [
        Transaction::from_sql_and_values(
            DbBackend::Postgres,
            r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
            [1u64.into()]
        ),
        Transaction::from_sql_and_values(
            DbBackend::Postgres,
            r#"SELECT "cake"."id", "cake"."name" FROM "cake""#,
            []
        ),
    ]
);
```

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

### ConnectOptions::new

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Creates new `ConnectOptions` for a database by passing in a URI string.

```APIDOC
## ConnectOptions::new

### Description
Create new ConnectOptions for a Database by passing in a URI string.

### Signature
```rust
pub fn new<T>(url: T) -> Self
where
    T: Into<String>,
```
```

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

### BigDecimal fractional_digit_count example

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.BigDecimal.html

Demonstrates how to get the scale of a BigDecimal, which represents the total number of digits to the right of the decimal point. This can be negative for very large numbers.

```rust
use bigdecimal::BigDecimal;
use std::str::FromStr;

let a = BigDecimal::from(12345);  // No fractional part
let b = BigDecimal::from_str("123.45").unwrap();  // Fractional part
let c = BigDecimal::from_str("0.0000012345").unwrap();  // Completely fractional part
let d = BigDecimal::from_str("5e9").unwrap();  // Negative-fractional part

assert_eq!(a.fractional_digit_count(), 0);
assert_eq!(b.fractional_digit_count(), 2);
assert_eq!(c.fractional_digit_count(), 10);
assert_eq!(d.fractional_digit_count(), -9);
```

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

### DatabaseTransaction::begin

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Initiates a new database transaction. It handles the necessary backend-specific setup for starting a transaction, including isolation levels and access modes.

```APIDOC
## DatabaseTransaction::begin

### Description

Initiates a new database transaction. It handles the necessary backend-specific setup for starting a transaction, including isolation levels and access modes.

### Method Signature

```rust
pub(crate) async fn begin(
    conn: Arc<Mutex<InnerConnection>>,
    backend: DbBackend,
    metric_callback: Option<crate::metric::Callback>,
    isolation_level: Option<IsolationLevel>,
    access_mode: Option<AccessMode>,
) -> Result<DatabaseTransaction, DbErr>
```

### Parameters

- `conn` (Arc<Mutex<InnerConnection>>): An asynchronous mutex-protected inner connection.
- `backend` (DbBackend): The database backend type.
- `metric_callback` (Option<crate::metric::Callback>): An optional callback for metrics.
- `isolation_level` (Option<IsolationLevel>): The desired transaction isolation level.
- `access_mode` (Option<AccessMode>): The desired transaction access mode.

### Returns

- `Result<DatabaseTransaction, DbErr>`: Returns a `DatabaseTransaction` on success, or a `DbErr` on failure.
```

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

### DeriveModel Usage Example

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/derive.DeriveModel.html

Demonstrates how to use the DeriveModel derive macro along with DeriveActiveModel. This setup is common for defining models that can be both read from and written to the database.

```rust
use sea_orm::entity::prelude::*;

#[derive(Clone, Debug, PartialEq, DeriveModel, DeriveActiveModel)]
pub struct Model {
    pub id: i32,
    pub name: String,
}
```

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

### Begin Transaction with Config

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.DatabaseTransaction.html

Executes the SQL `BEGIN` command with specified isolation level and/or access mode. Returns a `DatabaseTransaction` object.

```rust
fn begin_with_config<'life0, 'async_trait>(
    &'life0 self,
    isolation_level: Option<IsolationLevel>,
    access_mode: Option<AccessMode>,
) -> Pin<Box<dyn Future<Output = Result<DatabaseTransaction, DbErr>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

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

### Start Rollback (Internal)

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/transaction.rs.html

Initiates a rollback process for the transaction. This is typically called internally, for example, when a transaction is dropped, to ensure changes are discarded if not explicitly committed.

```APIDOC
## start_rollback

### Description
Queues a rollback for the transaction. This is often performed automatically when the transaction is dropped or when an error occurs.

### Method
`start_rollback()`

### Parameters
None

### Response
- `Ok(())` if the rollback initiation is successful.
- `Err(DbErr)` if the connection is disconnected or if attempting to drop a locked transaction.
```

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

### Begin Transaction with Mock Connection

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/driver/mock.rs.html

Initiates a new database transaction. This method acquires a lock on the mocker and calls its `begin` method. Panics if the lock cannot be acquired.

```rust
pub fn begin(&self) {
        self.mocker
            .lock()
            .expect("Failed to acquire mocker")
            .begin()
    }
```

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

### Get Monday-Based Week Number

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.TimeDateTimeWithTimeZone.html

Retrieve the week number where week 1 starts on a Monday, based on the date in the stored offset. The value ranges from 0 to 53.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).monday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).monday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).monday_based_week(), 0);
```

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

### ProxyDatabaseConnection begin method

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/driver/proxy.rs.html

Initiates a transaction block in the ProxyDatabase.

```rust
pub async fn begin(&self) {
        self.proxy.begin().await
    }
```

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

### Get Sunday-Based Week Number

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.TimeDateTimeWithTimeZone.html

Retrieve the week number where week 1 starts on a Sunday, based on the date in the stored offset. The value ranges from 0 to 53.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-01-01 0:00 UTC).sunday_based_week(), 0);
assert_eq!(datetime!(2020-12-31 0:00 UTC).sunday_based_week(), 52);
assert_eq!(datetime!(2021-01-01 0:00 UTC).sunday_based_week(), 0);
```

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

### Constructing a Raw SQL Transaction with SeaORM

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/entity/active_model.rs.html

Demonstrates how to build a raw SQL transaction for PostgreSQL using `Transaction::from_sql_and_values`. This is useful for complex updates or when SeaORM's ORM capabilities are insufficient.

```rust
Transaction::from_sql_and_values(
                    DbBackend::Postgres,
                    r#"UPDATE "fruit" SET "name" = $1, "cake_id" = $2 WHERE "fruit"."id" = $3 RETURNING "id", "name", "cake_id""#,
                    vec!["Apple".into(), Option::<i32>::None.into(), 1i32.into()],
                )
```

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

### Instantiate MockDatabase

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.MockDatabase.html

Instantiates a mock database, simulating a specific real-world SQL database backend. This is the starting point for setting up mock database interactions.

```rust
pub fn new(db_backend: DbBackend) -> Self
```

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

### Get Column Definition for Table Alteration

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/schema/entity.rs.html

Generates a ColumnDef for a specific column of an Entity, useful for table alteration statements. Includes a full example of altering a MySQL table.

```rust
use crate::sea_orm::IdenStatic;
use sea_orm::{
    ActiveModelBehavior, ColumnDef, ColumnTrait, ColumnType, DbBackend, EntityName, 
    EntityTrait, EnumIter, PrimaryKeyTrait, RelationDef, RelationTrait, Schema,
};
use sea_orm_macros::{DeriveEntityModel, DerivePrimaryKey};
use sea_query::{MysqlQueryBuilder, TableAlterStatement};

#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "posts")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: u32,
    pub title: String,
}

#[derive(Copy, Clone, Debug, EnumIter)]
pub enum Relation {}

impl RelationTrait for Relation {
    fn def(&self) -> RelationDef {
        panic!("No RelationDef")
    }
}
impl ActiveModelBehavior for ActiveModel {}

let schema = Schema::new(DbBackend::MySql);

let mut alter_table = TableAlterStatement::new()
    .table(Entity)
    .add_column(&mut schema.get_column_def::<Entity>(Column::Title))
    .take();
assert_eq!(
    alter_table.to_string(MysqlQueryBuilder::default()),
    "ALTER TABLE `posts` ADD COLUMN `title` varchar(255) NOT NULL"
);
```

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

### Instantiate from sqlx PgPool

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.SqlxPostgresConnector.html

Instantiates a DatabaseConnection from an existing sqlx::postgres::PgPool.

```rust
pub fn from_sqlx_postgres_pool(pool: PgPool) -> DatabaseConnection
```

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

### Iterate through weeks with NaiveDate

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Use `iter_weeks` to get an iterator that steps by weeks through all representable dates. The example shows forward and backward iteration, limiting the number of elements, and verifying against expected dates.

```rust
let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 5).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 12).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 19).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_weeks().take(4).enumerate() {
    assert_eq!(d, expected[idx]);
    count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 19).unwrap().iter_weeks().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}
```

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

### Connect to Database

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mod.rs.html

Establishes a database connection using provided options. It parses the connection string and routes to the appropriate connector based on the database backend. Returns an error if the connection string is invalid or no supporting driver is found.

```rust
pub async fn connect<C>(opt: C) -> Result<DatabaseConnection, DbErr>
where
    C: Into<ConnectOptions>,
{
    let opt: ConnectOptions = opt.into();

    if url::Url::parse(&opt.url).is_err() {
        return Err(conn_err(format!(
            "The connection string '{}' cannot be parsed.",
            opt.url
        )));
    }

    #[cfg(feature = "sqlx-mysql")]
    if DbBackend::MySql.is_prefix_of(&opt.url) {
        return crate::SqlxMySqlConnector::connect(opt).await;
    }
    #[cfg(feature = "sqlx-postgres")]
    if DbBackend::Postgres.is_prefix_of(&opt.url) {
        return crate::SqlxPostgresConnector::connect(opt).await;
    }
    #[cfg(feature = "sqlx-sqlite")]
    if DbBackend::Sqlite.is_prefix_of(&opt.url) {
        return crate::SqlxSqliteConnector::connect(opt).await;
    }
    #[cfg(feature = "mock")]
    if crate::MockDatabaseConnector::accepts(&opt.url) {
        return crate::MockDatabaseConnector::connect(&opt.url).await;
    }

    Err(conn_err(format!(
        "The connection string '{}' has no supporting driver.",
        opt.url
    )))
}
```

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

### ConnectOptions::new

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mod.rs.html

Creates new `ConnectOptions` for a database by providing a URI string.

```APIDOC
## ConnectOptions::new

### Description
Creates new `ConnectOptions` for a `Database` by passing in a URI string.

### Signature
```rust
pub fn new<T>(url: T) -> Self
where
    T: Into<String>,
```

### Parameters
* `url` (T): A type that can be converted into a String, representing the database connection URI.
```

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

### Iterate through days with NaiveDate

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/entity/prelude/struct.Date.html

Use `iter_days` to get an iterator that steps by days through all representable dates. The example demonstrates iterating forward and backward, taking a specific number of elements, and asserting equality with expected dates.

```rust
let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 28).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 29).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 1).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_days().take(4).enumerate() {
    assert_eq!(d, expected[idx]);
    count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 1).unwrap().iter_days().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}
```

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

### ProxyDatabaseTrait::query and ProxyDatabaseTrait::execute

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/proxy.rs.html

Example implementation of the `ProxyDatabaseTrait` for custom database interactions.

```APIDOC
## ProxyDatabaseTrait Implementation Example

### Description
This section shows an example implementation of the `ProxyDatabaseTrait` for a mock database. It demonstrates how to handle `query` and `execute` operations, printing the SQL statements and returning mock results.

### Methods
#### `query`
- **Purpose**: Executes a query and returns a vector of `ProxyRow`.
- **Signature**: `async fn query(&self, statement: Statement) -> Result<Vec<ProxyRow>, DbErr>`

#### `execute`
- **Purpose**: Executes a statement that does not return rows, returning information about the execution.
- **Signature**: `async fn execute(&self, statement: Statement) -> Result<ProxyExecResult, DbErr>`

### Example Usage
```rust
struct ProxyDb {}

impl ProxyDatabaseTrait for ProxyDb {
    async fn query(&self, statement: Statement) -> Result<Vec<ProxyRow>, DbErr> {
        println!("SQL query: {}", statement.sql);
        Ok(vec![].into())
    }

    async fn execute(&self, statement: Statement) -> Result<ProxyExecResult, DbErr> {
        println!("SQL execute: {}", statement.sql);
        Ok(ProxyExecResult { last_insert_id: 1, rows_affected: 1 })
    }
}
```
```

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

### Get Database URL

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the database URL of the pool.

```rust
pub fn get_url(&self) -> &str
```

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

### TryFromU64 Implementation for 7-element tuple

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.TryFromU64.html

Example of implementing TryFromU64 for a 7-element tuple where all elements implement TryFromU64. The conversion logic is not shown.

```rust
impl<T0, T1, T2, T3, T4, T5, T6> TryFromU64 for (T0, T1, T2, T3, T4, T5, T6)
where T0: TryFromU64, T1: TryFromU64, T2: TryFromU64, T3: TryFromU64, T4: TryFromU64, T5: TryFromU64, T6: TryFromU64,
Source§
#### fn try_from_u64(_: u64) -> Result<Self, DbErr>
```

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

### Get SQLx Logging Level

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the level of SQLx statement logging.

```rust
pub fn get_sqlx_logging_level(&self) -> LevelFilter
```

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

### Connect to Database

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.Database.html

Establishes a connection to a database using provided connection options. Returns an error if the database is unavailable.

```rust
pub async fn connect<C>(opt: C) -> Result<DatabaseConnection, DbErr>
where C: Into<ConnectOptions>,
```

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

### Get Idle Timeout

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the idle duration before closing a connection, if set.

```rust
pub fn get_idle_timeout(&self) -> Option<Duration>
```

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

### Get Connection Timeout

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the timeout duration when acquiring a connection, if set.

```rust
pub fn get_connect_timeout(&self) -> Option<Duration>
```

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

### OpenTransaction::init

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/database/mock.rs.html

Initializes a new `OpenTransaction` with a 'BEGIN' statement for PostgreSQL.

```APIDOC
## OpenTransaction::init

### Description
Initializes a new `OpenTransaction` with a 'BEGIN' statement for PostgreSQL.

### Method
`OpenTransaction::init() -> Self`
```

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

### Get Minimum Connections

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the minimum number of connections for the pool, if set.

```rust
pub fn get_min_connections(&self) -> Option<u32>
```

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

### TryFromU64 Implementation for 10-element tuple

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.TryFromU64.html

Example of implementing TryFromU64 for a 10-element tuple where all elements implement TryFromU64. The conversion logic is not shown.

```rust
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromU64 for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where T0: TryFromU64, T1: TryFromU64, T2: TryFromU64, T3: TryFromU64, T4: TryFromU64, T5: TryFromU64, T6: TryFromU64, T7: TryFromU64, T8: TryFromU64, T9: TryFromU64,
Source§
#### fn try_from_u64(_: u64) -> Result<Self, DbErr>
```

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

### Connect to Database with SeaORM

Source: https://docs.rs/sea-orm/1.1.14/src/sea_orm/driver/proxy.rs.html

Establishes a connection to the database using SeaORM's driver. Ensure the database URL is correctly configured.

```rust
async fn connect_to_db() -> Result<DatabaseConnection, DbErr> {
    let db_url = "postgres://user:password@host:port/database";
    Database::connect(db_url)
        .await
}
```

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

### Get Maximum Connections

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the maximum number of connections for the pool, if set.

```rust
pub fn get_max_connections(&self) -> Option<u32>
```

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

### Get SQLx Logging Status

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get whether SQLx statement logging is enabled.

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

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

### TryFromU64 Implementation for 5-element tuple

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/trait.TryFromU64.html

Example of implementing TryFromU64 for a 5-element tuple where all elements implement TryFromU64. The conversion logic is not shown.

```rust
impl<T0, T1, T2, T3, T4> TryFromU64 for (T0, T1, T2, T3, T4)
where T0: TryFromU64, T1: TryFromU64, T2: TryFromU64, T3: TryFromU64, T4: TryFromU64,
Source§
#### fn try_from_u64(_: u64) -> Result<Self, DbErr>
```

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

### Get Maximum Connection Lifetime

Source: https://docs.rs/sea-orm/1.1.14/sea_orm/struct.ConnectOptions.html

Get the maximum lifetime of individual connections, if set.

```rust
pub fn get_max_lifetime(&self) -> Option<Duration>
```
Tokens:
Raw