SeaORM

https://docs.rs/sea-orm/2.0.0-rc.34
Admin
SeaORM is a powerful ORM (Object-Relational Mapping) library for building web services in Rust with...
Tokens:1,484,313
Snippets:12,227
Trust Score:9.7
Update:18 hours ago
Show doc for...
Tokens:
Raw
### day() example

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

Returns the day of month starting from 1, ranging from 1 to 31. The last day of month differs by months.

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

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

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

### Insert and return model with exec_with_returning

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/trait.EntityTrait.html

Uses exec_with_returning to insert a model and get the inserted Model back. The example asserts the returned model has id 1 and verifies the SQL includes RETURNING "id", "name".

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

assert_eq!(
    cake::Entity::insert(cake::ActiveModel {
        id: NotSet,
        name: Set("Apple Pie".to_owned()),
    })
    .exec_with_returning(&db)
    .await?,
    cake::Model {
        id: 1,
        name: "Apple Pie".to_owned(),
    }
);

assert_eq!(
    db.into_transaction_log()[0].statements()[0].sql,
    r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id", "name""#
);
```

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

### group_by method examples

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/query/helper.rs.html

Illustrates the `group_by` method with two examples: grouping by a single column and grouping with aggregate functions (`count` and `sum`). Both produce PostgreSQL queries.

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

assert_eq!(
    cake::Entity::find()
        .select_only()
        .column(cake::Column::Name)
        .group_by(cake::Column::Name)
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name""#
);

assert_eq!(
    cake::Entity::find()
        .select_only()
        .column_as(cake::Column::Id.count(), "count")
        .column_as(cake::Column::Id.sum(), "sum_of_id")
        .group_by(cake::Column::Name)
        .build(DbBackend::Postgres)
        .to_string(),
    r#"SELECT COUNT("cake"."id") AS "count", SUM("cake"."id") AS "sum_of_id" FROM "cake" GROUP BY "cake"."name""#
);
```

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

### Get Month from NaiveDateTime

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

Shows how to use the month() method from the Datelike trait to get the month number starting from 1 (range 1 to 12). The example creates a NaiveDateTime and asserts that month() returns 9.

```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.month(), 9);
```

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

### begin

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.SqlxMySqlPoolConnection.html

Bundles a set of SQL statements that execute together.

```APIDOC
## begin

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

### Method
async fn begin

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

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

### Returns
- **Result<DatabaseTransaction, DbErr>** - A database transaction or a database error.
```

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

### Get Zero-Based Month from NaiveDateTime

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

Shows how to use the month0() method from the Datelike trait to get the month number starting from 0 (range 0 to 11). The example creates a NaiveDateTime and asserts that month0() returns 8.

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

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

### weekday() - Get weekday of date

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

Returns the weekday of the date in the stored offset. The examples show expected weekdays for specific dates.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).weekday(), Tuesday);
assert_eq!(datetime!(2019-02-01 0:00 UTC).weekday(), Friday);
assert_eq!(datetime!(2019-03-01 0:00 UTC).weekday(), Friday);
```

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

### begin

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/trait.ProxyDatabaseTrait.html

Begins a transaction in the ProxyDatabase. This is a provided method with a default implementation.

```APIDOC
## begin

### Description
Begin a transaction in the ProxyDatabase.

### Method
begin

### Parameters
None

### Returns
- `()` - An empty tuple indicating success.
```

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

### ConnectOptions::new

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.ConnectOptions.html

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

```APIDOC
## ConnectOptions::new

### Description
Creates a new ConnectOptions instance for a database by passing in a URI string.

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

### Parameters
- **url** (T) - Required - Database URI string.

### Returns
- **Self** - A new ConnectOptions instance.
```

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

### to_hms() - Get hour, minute, second

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

Returns the clock hour, minute, and second as a tuple. Examples show expected values for midnight and end-of-day.

```rust
assert_eq!(datetime!(2020-01-01 0:00:00 UTC).to_hms(), (0, 0, 0));
assert_eq!(datetime!(2020-01-01 23:59:59 UTC).to_hms(), (23, 59, 59));
```

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

### Time::as_hms example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the clock hour, minute, and second as a tuple. The example asserts values for midnight and 23:59:59.

```rust
assert_eq!(time!(0:00:00).as_hms(), (0, 0, 0));
assert_eq!(time!(23:59:59).as_hms(), (23, 59, 59));
```

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

### INSERT example (Postgres) for ActiveModelTrait

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/entity/active_model.rs.html

Shows how to perform an INSERT operation on an ActiveModel using a mock database with Postgres backend. The example is incomplete in the source, so only the visible portion is included.

```rust
/// # Example (Postgres)
///
/// ```
/// # use sea_orm::{error::*, tests_cfg::*, *};
/// #
/// # #[smol_potat::main]
/// # #[cfg(feature = "mock")]
/// # pub async fn main() -> Result<(), DbErr> {
/// #
/// # let db = MockDatabase::new(DbBackend::Postgres)
/// #     .append_query_results([
/// #         [cake::Model {
/// #             id: 15,
```

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

### month0() example

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

Returns the month number starting from 0, ranging 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);
```

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

### Test setup_num_items function

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/executor/paginator.rs.html

Creates a mock database with a single query result containing num_items value. Returns the connection and the number of items.

```rust
fn setup_num_items() -> (DatabaseConnection, i64) {
    let num_items = 3;
    let db = MockDatabase::new(DbBackend::Postgres)
        .append_query_results([[maplit::btreemap! {
            "num_items" => Into::<Value>::into(num_items),
        }]])
        .into_connection();

    (db, num_items)
}
```

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

### ConnectOptions::new constructor

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/database/mod.rs.html

Creates new ConnectOptions from a URI string. Sets default values for pool settings, logging, and timeouts.

```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,
        application_name: None,
        test_before_acquire: true,
        connect_lazy: false,
        after_connect: None,
        #[cfg(feature = "sqlx-mysql")]
        mysql_opts_fn: None,
        #[cfg(feature = "sqlx-postgres")]
        pg_opts_fn: None,
        #[cfg(feature = "sqlx-sqlite")]
        sqlite_opts_fn: None,
    }
}
```

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

### month() example

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

Returns the month number starting from 1, ranging from 1 to 12.

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

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

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

### into_query

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Takes ownership of the query builder.

```APIDOC
## into_query

### Description
Takes ownership of the query builder.

### Method
`fn into_query(self) -> SelectStatement`

### Parameters
None

### Returns
- `SelectStatement` - The owned query builder.
```

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

### Time::as_hms_nano example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the clock hour, minute, second, and nanosecond as a tuple. The example asserts values for midnight and 23:59:59.999_999_999.

```rust
assert_eq!(time!(0:00:00).as_hms_nano(), (0, 0, 0, 0));
assert_eq!(
    time!(23:59:59.999_999_999).as_hms_nano(),
    (23, 59, 59, 999_999_999)
);
```

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

### Test setup function with mock pages

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/executor/paginator.rs.html

Creates a mock database with three pages of fruit models and returns the connection and pages. Used for pagination tests.

```rust
fn setup() -> (DatabaseConnection, Vec<Vec<fruit::Model>>) {
    let page1 = vec![
        fruit::Model {
            id: 1,
            name: "Blueberry".into(),
            cake_id: Some(1),
        },
        fruit::Model {
            id: 2,
            name: "Raspberry".into(),
            cake_id: Some(1),
        },
    ];

    let page2 = vec![fruit::Model {
        id: 3,
        name: "Strawberry".into(),
        cake_id: Some(2),
    }];

    let page3 = Vec::<fruit::Model>::new();

    let db = MockDatabase::new(DbBackend::Postgres)
        .append_query_results([page1.clone(), page2.clone(), page3.clone()])
        .into_connection();

    (db, vec![page1, page2, page3])
}
```

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

### Time::as_hms_micro example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the clock hour, minute, second, and microsecond as a tuple. The example asserts values for midnight and 23:59:59.999_999.

```rust
assert_eq!(time!(0:00:00).as_hms_micro(), (0, 0, 0, 0));
assert_eq!(
    time!(23:59:59.999_999).as_hms_micro(),
    (23, 59, 59, 999_999)
);
```

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

### fetch_and_next doc example (truncated)

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/executor/paginator.rs.html

Documentation example for the fetch_and_next method, showing usage with a mock database. The example is truncated in the source and cannot be fully reconstructed.

```rust
/// Fetch one page and increment the page counter
    ///
    /// ```
    /// # use sea_orm::{error::*, tests_cfg::*, *};
    /// #
    /// # #[smol_potat::main]
    /// # #[cfg(feature = "mock")]
    /// # pub async fn main() -> Result<(), DbErr> {
    /// #
    /// # let owned_db = MockDatabase::new(DbBackend::Postgres)
    /// #     .append_query_results([
    /// #         vec![cake::Model {
    /// #             id: 1,
    /// #             name: "Cake".to_owned(),
    /// #         }],
    /// #         vec![],
    /// #     ])
    /// #     .into_connection();
    /// # let db = &owned_db;
    /// #
    /// use sea_orm::{entity::*, query::*, tests_cfg::cake};
    /// let mut cake_pages = cake::Entity::find()
```

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

### Time::as_hms_milli example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the clock hour, minute, second, and millisecond as a tuple. The example asserts values for midnight and 23:59:59.999.

```rust
assert_eq!(time!(0:00:00).as_hms_milli(), (0, 0, 0, 0));
assert_eq!(time!(23:59:59.999).as_hms_milli(), (23, 59, 59, 999));
```

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

### columns method example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/query/helper.rs.html

Shows how to use the `columns` method to select multiple columns in a SeaORM query. The example builds a MySQL query selecting `name` and `tea` columns from the `lunch_set` entity.

```rust
assert_eq!(
    lunch_set::Entity::find()
        .select_only()
        .columns([lunch_set::Column::Name, lunch_set::Column::Tea])
        .build(DbBackend::MySql)
        .to_string(),
    r#"SELECT `lunch_set`.`name`, `lunch_set`.`tea` FROM `lunch_set`"#
);
```

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

### Time::hour example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the clock hour, always in the range 0..24. The example asserts values for midnight and 23:59:59.

```rust
assert_eq!(time!(0:00:00).hour(), 0);
assert_eq!(time!(23:59:59).hour(), 23);
```

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

### having method example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/query/helper.rs.html

Shows the `having` method adding an AND HAVING expression. The example chains two `having` calls with equality conditions on the `id` column and builds a MySQL query.

```rust
use sea_orm::{sea_query::{Alias, Expr, ExprTrait}, entity::*, query::*, tests_cfg::cake, DbBackend};

assert_eq!(
    cake::Entity::find()
        .having(cake::Column::Id.eq(4))
        .having(cake::Column::Id.eq(5))
        .build(DbBackend::MySql)
        .to_string(),
```

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

### to_hms_nano() - Get hour, minute, second, nanosecond

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

Returns the clock hour, minute, second, and nanosecond as a tuple. Examples show expected values for midnight and a time with nanoseconds.

```rust
assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_nano(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999_999_999 UTC).to_hms_nano(),
    (23, 59, 59, 999_999_999)
);
```

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

### to_hms_micro() - Get hour, minute, second, microsecond

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

Returns the clock hour, minute, second, and microsecond as a tuple. Examples show expected values for midnight and a time with microseconds.

```rust
assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_micro(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999_999 UTC).to_hms_micro(),
    (23, 59, 59, 999_999)
);
```

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

### Entity, Model, and ActiveModel Example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/entity/mod.rs.html

Example from the module documentation showing how to define an Entity, Model, ActiveModel, Column, PrimaryKey, and Relation using SeaORM macros and traits. Requires the 'macros' feature. Demonstrates manual implementation of PrimaryKeyTrait and ColumnTrait.

```rust
/// This modules contains types and traits for an  Entity, ActiveMode, Model, PrimaryKey, ForeignKey and Relations.
///
/// // An Entity
/// A unit struct implements [EntityTrait](crate::EntityTrait) representing a table in the database.
///
/// This trait contains the properties of an entity including
///
/// - The Table Name which is implemented by [EntityName](crate::EntityName)
/// - The Column which is implemented by [ColumnTrait](crate::ColumnTrait)
/// - A Relation which is implemented by [RelationTrait](crate::RelationTrait)
/// - The Primary Key which is implemented by [PrimaryKeyTrait](crate::PrimaryKeyTrait)
///   and [PrimaryKeyToColumn](crate::PrimaryKeyToColumn)
///
/// This trait also provides an API for CRUD actions
///
/// #### Example for creating an Entity, Model and ActiveModel
/// ```
/// #[cfg(feature = "macros")]
/// # use sea_orm::entity::prelude::*;
/// use sea_orm::ActiveModelBehavior;
/// use sea_orm::ColumnDef;
/// use sea_orm::ColumnTrait;
/// use sea_orm::ColumnType;
/// use sea_orm::EntityName;
/// use sea_orm::PrimaryKeyTrait;
/// use sea_orm::RelationDef;
/// use sea_orm::RelationTrait;
///
/// // Use [DeriveEntity] to derive the EntityTrait automatically
/// #[derive(Copy, Clone, Default, Debug, DeriveEntity)]
/// pub struct Entity;
///
/// /// The [EntityName] describes the name of a table
/// impl EntityName for Entity {
///     fn table_name(&self) -> &'static str {
///         "filling"
///     }
/// }
///
/// // Create a Model for the Entity through [DeriveModel].
/// // The `Model` handles `READ` operations on a table in a database.
/// // The [DeriveActiveModel] creates a way to perform `CREATE` , `READ` and `UPDATE` operations
/// // in a database
/// #[derive(Clone, Debug, PartialEq, DeriveModel, DeriveActiveModel)]
/// pub struct Model {
///     pub id: i32,
///     pub name: String,
/// }
///
/// // Use the [DeriveColumn] to create a Column for an the table called Entity
/// // The [EnumIter] which creates a new type that iterates of the variants of a Column.
/// #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
/// pub enum Column {
///     Id,
///     Name,
/// }
///
/// // Create a PrimaryKey for the Entity using the [PrimaryKeyTrait]
/// // The [EnumIter] which creates a new type that iterates of the variants of a PrimaryKey.
/// #[derive(Copy, Clone, Debug, EnumIter, DerivePrimaryKey)]
/// pub enum PrimaryKey {
///     Id,
/// }
///
/// // Or implement the [PrimaryKeyTrait] manually instead of using the macro [DerivePrimaryKey]
/// impl PrimaryKeyTrait for PrimaryKey {
///     type ValueType = i32;
///
///     fn auto_increment() -> bool {
///         true
///     }
/// }
///
/// #[derive(Copy, Clone, Debug, EnumIter)]
/// pub enum Relation {}
///
/// impl ColumnTrait for Column {
///     type EntityName = Entity;
///
///     fn def(&self) -> ColumnDef {
///         match self {
///             Self::Id => ColumnType::Integer.def(),
///             Self::Name => ColumnType::String(StringLen::None).def(),
///         }
///     }
/// }
///
/// // Create a Relation for the Entity
/// impl RelationTrait for Relation {
///     fn def(&self) -> RelationDef {
///         unimplemented!()
///     }
/// }
///
/// // Implement user defined operations for CREATE, UPDATE and DELETE operations
/// // to create an ActiveModel using the [ActiveModelBehavior]
/// impl ActiveModelBehavior for ActiveModel {}
/// ```
```

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

### into_tuple example with multiple columns and group_by

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Shows how to use into_tuple with multiple columns and group_by to return tuples.

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

let res: Vec<(String, i64)> = cake::Entity::find()
    .select_only()
    .column(cake::Column::Name)
    .column(cake::Column::Id)
    .group_by(cake::Column::Name)
    .into_tuple()
    .all(&db)
    .await?;

assert_eq!(res, vec![("Chocolate Forest".to_owned(), 2i64)]);

assert_eq!(
    db.into_transaction_log(),
    vec![Transaction::from_sql_and_values(
        DbBackend::Postgres,
        vec![
            r#"SELECT "cake"."name", "cake"."id""#,
            r#"FROM "cake" GROUP BY "cake"."name""#,
        ]
        .join(" ")
        .as_str(),
        vec![]
    )]
);
```

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

### to_hms_milli() - Get hour, minute, second, millisecond

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

Returns the clock hour, minute, second, and millisecond as a tuple. Examples show expected values for midnight and a time with milliseconds.

```rust
assert_eq!(
    datetime!(2020-01-01 0:00:00 UTC).to_hms_milli(),
    (0, 0, 0, 0)
);
assert_eq!(
    datetime!(2020-01-01 23:59:59.999 UTC).to_hms_milli(),
    (23, 59, 59, 999)
);
```

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

### Test module setup for mock database

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/database/mock.rs.html

Sets up the test module with necessary imports, a custom error type, and a test function that creates a mock database connection.

```rust
#[cfg(test)]
#[cfg(feature = "mock")]
mod tests {
    #[cfg(feature = "sync")]
    use crate::util::StreamShim;
    use crate::{
        DbBackend, DbErr, IntoMockRow, MockDatabase, Statement, Transaction, TransactionError,
        TransactionTrait, entity::*, error::*, tests_cfg::*,
    };
    use futures_util::{TryStreamExt, stream::TryNext};
    use pretty_assertions::assert_eq;

    #[derive(Debug, PartialEq, Eq)]
    pub struct MyErr(String);

    impl std::error::Error for MyErr {}

    impl std::fmt::Display for MyErr {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            write!(f, "{}", self.0.as_str())
        }
    }

    #[smol_potat::test]
    async fn test_transaction_1() {
        let db = MockDatabase::new(DbBackend::Postgres).into_connection();

```

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

### Time::second example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the second within the minute, always in the range 0..60. The example asserts values for midnight and 23:59:59.

```rust
assert_eq!(time!(0:00:00).second(), 0);
assert_eq!(time!(23:59:59).second(), 59);
```

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

### Time::minute example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Gets the minute within the hour, always in the range 0..60. The example asserts values for midnight and 23:59:59.

```rust
assert_eq!(time!(0:00:00).minute(), 0);
assert_eq!(time!(23:59:59).minute(), 59);
```

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

### begin

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.SqlxSqlitePoolConnection.html

Bundles a set of SQL statements that execute together. This starts a database transaction.

```APIDOC
## begin

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

### Method
async fn begin

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

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

### Returns
- **Result<DatabaseTransaction, DbErr>** - A database transaction or a database error.
```

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

### hour() - Get clock hour

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

Returns the clock hour in the stored offset, always in the range 0..24. Examples show expected values for UTC and an offset of -2.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).hour(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(-2))
        .hour(),
    21,
);
```

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

### Example: Deriving ActiveModelBehavior for a cake entity

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/trait.ActiveModelBehavior.html

Shows a complete example of defining an Entity and Model for a 'cake' table, then implementing ActiveModelBehavior for the derived ActiveModel. This is the minimal setup to use the trait.

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

 // Use [DeriveEntity] to derive the EntityTrait automatically
#[derive(Copy, Clone, Default, Debug, DeriveEntity)]
pub struct Entity;

/// The [EntityName] describes the name of a table
impl EntityName for Entity {
    fn table_name(&self) -> &'static str {
        "cake"
    }
}

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

impl ActiveModelBehavior for ActiveModel {}
```

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

### begin

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.MockDatabaseConnection.html

Creates a statement block of SQL statements that execute together. This starts a transaction.

```APIDOC
## begin

### Description
Creates a statement block of SQL statements that execute together.

### Method
Transaction

### Signature
pub fn begin(&self)

### Panics
Will panic if the lock cannot be acquired.
```

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

### order_by method with example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/query/helper.rs.html

Adds an ORDER BY clause to the query. The example shows ordering by `id` ascending and `name` descending on the `cake` table.

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

assert_eq!(
    cake::Entity::find()
        .order_by(cake::Column::Id, Order::Asc)
        .order_by(cake::Column::Name, Order::Desc)
        .build(DbBackend::MySql)
        .to_string(),
    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` ORDER BY `cake`.`id` ASC, `cake`.`name` DESC"
);
```

```rust
fn order_by<C>(mut self, col: C, ord: Order) -> Self
where
    C: IntoSimpleExpr,
{

```

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

### nanosecond() - Get nanoseconds within second

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

Returns the nanoseconds within the second in the stored offset, always in the range 0..1_000_000_000. Examples show expected values for midnight and a time with nanoseconds.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).nanosecond(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59.999_999_999 UTC).nanosecond(),
    999_999_999,
);
```

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

### microsecond() - Get microseconds within second

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

Returns the microseconds within the second in the stored offset, always in the range 0..1_000_000. Examples show expected values for midnight and a time with microseconds.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).microsecond(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59.999_999 UTC).microsecond(),
    999_999,
);
```

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

### begin_with_config

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/trait.TransactionTrait.html

Executes a SQL BEGIN transaction with optional isolation level and/or access mode, returning a Transaction that can be committed or rolled back.

```APIDOC
## begin_with_config

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

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

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

### Returns
- `Result<Self::Transaction, DbErr>` - A future resolving to a `Transaction` on success or a `DbErr` on failure.

```

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

### millisecond() - Get milliseconds within second

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

Returns the milliseconds within the second in the stored offset, always in the range 0..1_000. Examples show expected values for midnight and a time with milliseconds.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).millisecond(), 0);
assert_eq!(datetime!(2019-01-01 23:59:59.999 UTC).millisecond(), 999);
```

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

### format() example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/entity/prelude/struct.TimeTime.html

Formats the Time using a format description. Requires the `formatting` crate feature. The example parses a format description and formats a time.

```rust
let format = format_description::parse("[hour]:[minute]:[second]")?;
assert_eq!(time!(12:00).format(&format)?, "12:00:00");
```

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

### second() - Get second within minute

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

Returns the second within the minute in the stored offset, always in the range 0..60. Examples show expected values for UTC and an offset of +0:00:30.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).second(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(+0:00:30))
        .second(),
    29,
);
```

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

### build

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Builds the query as a Statement.

```APIDOC
## build

### Description
Builds the query as a Statement.

### Method
`fn build(&self, db_backend: DbBackend) -> Statement`

### Parameters
- **db_backend** (DbBackend) - Required - The database backend.

### Returns
- `Statement` - The built statement.
```

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

### Ergonomic Raw SQL with raw_sql! Macro

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/lib.rs.html

Use raw SQL for complex queries that are too difficult to express with the query builder. Demonstrates nested parameter access with `{user.name}` and array expansion with `{..ids}`. The example uses the `Sqlite` dialect and returns a single `user::Model`.

```rust
# use sea_orm::{DbErr, DbConn};
# async fn function(db: &DbConn) -> Result<(), DbErr> {
# use sea_orm::{entity::*, query::*, tests_cfg::*, raw_sql};
# struct Item<'a> { name: &'a str }
let user = Item { name: "Bob" }; // nested parameter access
let ids = [2, 3, 4]; // expanded by the `..` operator

let user: Option<user::Model> = user::Entity::find()
    .from_raw_sql(raw_sql!(
        Sqlite,
        r#"SELECT "id", "name" FROM "user"
           WHERE "name" LIKE {user.name}
           AND "id" in ({..ids})
        "#
    ))
    .one(db)
    .await?;
# Ok(())
# }
```

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

### minute() - Get minute within hour

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

Returns the minute within the hour in the stored offset, always in the range 0..60. Examples show expected values for UTC and an offset of +0:30.

```rust
assert_eq!(datetime!(2019-01-01 0:00 UTC).minute(), 0);
assert_eq!(
    datetime!(2019-01-01 23:59:59 UTC)
        .to_offset(offset!(+0:30))
        .minute(),
    29,
);
```

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

### Get Year from NaiveDateTime

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

Shows how to use the year() method from the Datelike trait to get the year number in the calendar date. The example creates a NaiveDateTime and asserts that year() returns 2015.

```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.year(), 2015);
```

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

### from_num_days_from_ce_opt example

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

Constructs a NaiveDate from a day number in the proleptic Gregorian calendar, with January 1, 1 as day 1. Returns None for out-of-range dates.

```rust
use chrono::NaiveDate;

let from_ndays_opt = NaiveDate::from_num_days_from_ce_opt;
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

assert_eq!(from_ndays_opt(730_000), Some(from_ymd(1999, 9, 3)));
assert_eq!(from_ndays_opt(1), Some(from_ymd(1, 1, 1)));
assert_eq!(from_ndays_opt(0), Some(from_ymd(0, 12, 31)));
assert_eq!(from_ndays_opt(-1), Some(from_ymd(0, 12, 30)));
assert_eq!(from_ndays_opt(100_000_000), None);
assert_eq!(from_ndays_opt(-100_000_000), None);
```

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

### to_julian_day() - Get Julian day

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

Returns the Julian day for the date, ignoring time. The algorithm is derived from Peter Baum's method. Examples show expected Julian day values for various dates.

```rust
assert_eq!(datetime!(-4713-11-24 0:00 UTC).to_julian_day(), 0);
assert_eq!(datetime!(2000-01-01 0:00 UTC).to_julian_day(), 2_451_545);
assert_eq!(datetime!(2019-01-01 0:00 UTC).to_julian_day(), 2_458_485);
assert_eq!(datetime!(2019-12-31 0:00 UTC).to_julian_day(), 2_458_849);
```

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

### into_values example with multiple columns and group_by

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Shows how to use into_values with multiple columns and group_by to return tuples.

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

#[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
enum QueryAs {
    CakeName,
    NumOfCakes,
}

let res: Vec<(String, i64)> = cake::Entity::find()
    .select_only()
    .column_as(cake::Column::Name, QueryAs::CakeName)
    .column_as(cake::Column::Id.count(), QueryAs::NumOfCakes)
    .group_by(cake::Column::Name)
    .into_values::<_, QueryAs>()
    .all(&db)
    .await?;

assert_eq!(res, [("Chocolate Forest".to_owned(), 2i64)]);

assert_eq!(
    db.into_transaction_log(),
    [Transaction::from_sql_and_values(
        DbBackend::Postgres,
        [
            r#"SELECT "cake"."name" AS "cake_name", COUNT("cake"."id") AS "num_of_cakes""#,
            r#"FROM "cake" GROUP BY "cake"."name""#,
        ]
        .join(" ")
        .as_str(),
        []
    )]
);
```

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

### ordinal0() example

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

Returns the day of year starting from 0, ranging from 0 to 365. The last day of year differs by years.

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

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

### consolidate() usage examples

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.SelectThree.html

Shows how to use consolidate() to group query results by join topology. The first example groups fruit->cake->filling, the second groups cake with fruit and filling as separate vectors.

```rust
// fruit -> cake -> filling
let items: Vec<(fruit::Model, Vec<(cake::Model, Vec<filling::Model>)>)> = fruit::Entity::find()
    .find_also_related(cake::Entity)
    .and_also_related(filling::Entity)
    .consolidate()
    .all(db)
    .await?;

// cake -> fruit
//      -> filling
let items: Vec<(cake::Model, Vec<fruit::Model>, Vec<filling::Model>)> = cake::Entity::find()
    .find_also_related(fruit::Entity)
    .find_also_related(filling::Entity)
    .consolidate()
    .all(db)
    .await?;
```

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

### ordinal() example

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

Returns the day of year starting from 1, ranging from 1 to 366. The last day of year differs by years.

```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(&self)

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.ProxyDatabaseConnection.html

Starts a transaction by creating a statement block of SQL statements that execute together. This is an asynchronous method.

```APIDOC
## begin(&self)

### Description
Creates a statement block of SQL statements that execute together.

### Method
Async method

### Parameters
- **self** - The ProxyDatabaseConnection instance.

### Returns
- No return value.
```

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

### Insert ActiveModel (Postgres)

Source: https://docs.rs/sea-orm/2.0.0-rc.34/src/sea_orm/entity/active_model.rs.html

Shows how to insert an ActiveModel using the `insert` method with a Postgres mock database. The example asserts the returned model and the generated SQL with `RETURNING` clause.

```rust
/// #             name: "Apple Pie".to_owned(),
/// #         }],
/// #     ])
/// #     .into_connection();
/// #
/// use sea_orm::{entity::*, query::*, tests_cfg::cake};
///
/// let apple = cake::ActiveModel {
///     name: Set("Apple Pie".to_owned()),
///     ..Default::default()
/// };
///
/// assert_eq!(
///     apple.insert(&db).await?,
///     cake::Model {
///         id: 15,
///         name: "Apple Pie".to_owned(),
///     }
/// );
///
/// assert_eq!(
///     db.into_transaction_log(),
///     [Transaction::from_sql_and_values(
///         DbBackend::Postgres,
///         r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id", "name""#,
///         ["Apple Pie".into()]
///     )]
/// );
/// #
/// # Ok(())
/// # }
```

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

### day0() example

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

Returns the day of month starting from 0, ranging from 0 to 30. The last day of month differs by months.

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

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

### as_query

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Returns an immutable reference to the query builder.

```APIDOC
## as_query

### Description
Returns an immutable reference to the query builder.

### Method
`fn as_query(&self) -> &SelectStatement`

### Parameters
None

### Returns
- `&SelectStatement` - Immutable reference to the query builder.
```

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

### fetch_and_next usage example

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/struct.Paginator.html

Shows how to iterate over all pages using fetch_and_next, which fetches one page and increments the page counter. The loop continues until None is returned, processing each page as a Vec<cake::Model>.

```rust
use sea_orm::{entity::*, query::*, tests_cfg::cake};
let mut cake_pages = cake::Entity::find()
    .order_by_asc(cake::Column::Id)
    .paginate(db, 50);

while let Some(cakes) = cake_pages.fetch_and_next().await? {
    // Do something on cakes: Vec<cake::Model>
}
```

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

### ordinal0() example

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

Returns the day of year starting from 0 (range 0-365). See also NaiveDate::ordinal0.

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

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

### ordinal() example

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

Returns the day of year starting from 1 (range 1-366). See also NaiveDate::ordinal.

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

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

### into_partial_model example with DerivePartialModel

Source: https://docs.rs/sea-orm/2.0.0-rc.34/sea_orm/query/struct.Select.html

Shows how to use into_partial_model with a derived PartialModel to select specific columns and computed expressions.

```rust
use sea_orm::{
    entity::*,
    query::*,
    tests_cfg::cake::{self, Entity as Cake},
    DbBackend, DerivePartialModel,
};
use sea_query::{Expr, Func, SimpleExpr};

#[derive(DerivePartialModel)]
#[sea_orm(entity = "Cake")]
struct PartialCake {
    name: String,
    #[sea_orm(
        from_expr = r#"SimpleExpr::FunctionCall(Func::upper(Expr::col((Cake, cake::Column::Name))))"#
    )]
    name_upper: String,
}

assert_eq!(
    cake::Entity::find()
        .into_partial_model::<PartialCake>()
        .into_statement(DbBackend::Sqlite)
        .to_string(),
    r#"SELECT "cake"."name" AS "name", UPPER("cake"."name") AS "name_upper" FROM "cake""#
);
```

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

### day0() example

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

Returns the day of month starting from 0 (range 0-30). See also NaiveDate::day0.

```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);
```
Tokens:
Raw