Trait ActiveModelTrait 

pub trait ActiveModelTrait: Clone + Debug {
    type Entity: EntityTrait;

    // Required methods
    fn take(
        &mut self,
        c: <Self::Entity as EntityTrait>::Column,
    ) -> ActiveValue<Value>;
    fn get(
        &self,
        c: <Self::Entity as EntityTrait>::Column,
    ) -> ActiveValue<Value>;
    fn set_if_not_equals(
        &mut self,
        c: <Self::Entity as EntityTrait>::Column,
        v: Value,
    );
    fn try_set(
        &mut self,
        c: <Self::Entity as EntityTrait>::Column,
        v: Value,
    ) -> Result<(), DbErr>;
    fn not_set(&mut self, c: <Self::Entity as EntityTrait>::Column);
    fn is_not_set(&self, c: <Self::Entity as EntityTrait>::Column) -> bool;
    fn default() -> Self;
    fn default_values() -> Self;
    fn reset(&mut self, c: <Self::Entity as EntityTrait>::Column);

    // Provided methods
    fn set(&mut self, c: <Self::Entity as EntityTrait>::Column, v: Value) { ... }
    fn reset_all(self) -> Self { ... }
    fn get_primary_key_value(&self) -> Option<ValueTuple> { ... }
    fn insert<'a, 'async_trait, C>(
        self,
        db: &'a C,
    ) -> Pin<Box<dyn Future<Output = Result<<Self::Entity as EntityTrait>::Model, DbErr>> + Send + 'async_trait>>
       where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>,
             Self: ActiveModelBehavior + Send + 'async_trait,
             C: ConnectionTrait + 'async_trait,
             'a: 'async_trait { ... }
    fn update<'a, 'async_trait, C>(
        self,
        db: &'a C,
    ) -> Pin<Box<dyn Future<Output = Result<<Self::Entity as EntityTrait>::Model, DbErr>> + Send + 'async_trait>>
       where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>,
             Self: ActiveModelBehavior + Send + 'async_trait,
             C: ConnectionTrait + 'async_trait,
             'a: 'async_trait { ... }
    fn save<'a, 'async_trait, C>(
        self,
        db: &'a C,
    ) -> Pin<Box<dyn Future<Output = Result<Self, DbErr>> + Send + 'async_trait>>
       where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>,
             Self: ActiveModelBehavior + Send + 'async_trait,
             C: ConnectionTrait + 'async_trait,
             'a: 'async_trait { ... }
    fn delete<'a, 'async_trait, C>(
        self,
        db: &'a C,
    ) -> Pin<Box<dyn Future<Output = Result<DeleteResult, DbErr>> + Send + 'async_trait>>
       where Self: ActiveModelBehavior + Send + 'async_trait,
             C: ConnectionTrait + 'async_trait,
             'a: 'async_trait { ... }
    fn set_from_json(&mut self, json: Value) -> Result<(), DbErr>
       where Self: TryIntoModel<<Self::Entity as EntityTrait>::Model>,
             for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> + Serialize { ... }
    fn from_json(json: Value) -> Result<Self, DbErr>
       where Self: TryIntoModel<<Self::Entity as EntityTrait>::Model>,
             for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> + Serialize { ... }
    fn is_changed(&self) -> bool { ... }
    fn find_related<R>(&self, _: R) -> Select<R>
       where R: EntityTrait,
             Self::Entity: Related<R> { ... }
}

ActiveModel is a type for constructing INSERT and UPDATE statements for a particular table.

Like [Model][ModelTrait], it represents a database record and each field represents a column.

But unlike [Model][ModelTrait], it also stores additional state for every field, and fields are not guaranteed to have a value.

This allows you to:

• omit columns from the query,
• know which columns have changed after editing a record.

Required Associated Types

type Entity: EntityTrait

The Entity this ActiveModel belongs to

Required Methods

fn take( &mut self, c: <Self::Entity as EntityTrait>::Column, ) -> ActiveValue<Value>

Get a mutable ActiveValue from an ActiveModel

fn get(&self, c: <Self::Entity as EntityTrait>::Column) -> ActiveValue<Value>

Get a immutable ActiveValue from an ActiveModel

fn set_if_not_equals( &mut self, c: <Self::Entity as EntityTrait>::Column, v: Value, )

Set the Value of a ActiveModel field if value is different, panic if failed

fn try_set( &mut self, c: <Self::Entity as EntityTrait>::Column, v: Value, ) -> Result<(), DbErr>

Set the Value of a ActiveModel field, return error if failed

fn not_set(&mut self, c: <Self::Entity as EntityTrait>::Column)

Set the state of an ActiveValue to the not set state

fn is_not_set(&self, c: <Self::Entity as EntityTrait>::Column) -> bool

Check the state of a ActiveValue

fn default() -> Self

Create an ActiveModel with all fields to NotSet

fn default_values() -> Self

Create an ActiveModel with all fields to Set(default_value) if Default is implemented, NotSet otherwise

fn reset(&mut self, c: <Self::Entity as EntityTrait>::Column)

Reset the value from ActiveValue::Unchanged to ActiveValue::Set, leaving ActiveValue::NotSet untouched.

Provided Methods

fn set(&mut self, c: <Self::Entity as EntityTrait>::Column, v: Value)

Set the Value of a ActiveModel field, panic if failed

fn reset_all(self) -> Self

Reset all values from ActiveValue::Unchanged to ActiveValue::Set, leaving ActiveValue::NotSet untouched.

fn get_primary_key_value(&self) -> Option<ValueTuple>

Get the primary key of the ActiveModel, only if it’s fully specified.

fn insert<'a, 'async_trait, C>( self, db: &'a C, ) -> Pin<Box<dyn Future<Output = Result<<Self::Entity as EntityTrait>::Model, DbErr>> + Send + 'async_trait>>

where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>, Self: ActiveModelBehavior + Send + 'async_trait, C: ConnectionTrait + 'async_trait, 'a: 'async_trait,

Perform an INSERT operation on the ActiveModel

Example (Postgres)

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()]
    )]
);

Example (MySQL)

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::MySql,
            r#"INSERT INTO `cake` (`name`) VALUES (?)"#,
            ["Apple Pie".into()]
        ),
        Transaction::from_sql_and_values(
            DbBackend::MySql,
            r#"SELECT `cake`.`id`, `cake`.`name` FROM `cake` WHERE `cake`.`id` = ? LIMIT ?"#,
            [15.into(), 1u64.into()]
        )
    ]
);

fn update<'a, 'async_trait, C>( self, db: &'a C, ) -> Pin<Box<dyn Future<Output = Result<<Self::Entity as EntityTrait>::Model, DbErr>> + Send + 'async_trait>>

where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>, Self: ActiveModelBehavior + Send + 'async_trait, C: ConnectionTrait + 'async_trait, 'a: 'async_trait,

Perform the UPDATE operation on an ActiveModel

Example (Postgres)

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

let orange = fruit::ActiveModel {
    id: Set(1),
    name: Set("Orange".to_owned()),
    ..Default::default()
};

assert_eq!(
    orange.update(&db).await?,
    fruit::Model {
        id: 1,
        name: "Orange".to_owned(),
        cake_id: None,
    }
);

assert_eq!(
    db.into_transaction_log(),
    [Transaction::from_sql_and_values(
        DbBackend::Postgres,
        r#"UPDATE "fruit" SET "name" = $1 WHERE "fruit"."id" = $2 RETURNING "id", "name", "cake_id""#,
        ["Orange".into(), 1i32.into()]
    )]);

Example (MySQL)

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

let orange = fruit::ActiveModel {
    id: Set(1),
    name: Set("Orange".to_owned()),
    ..Default::default()
};

assert_eq!(
    orange.update(&db).await?,
    fruit::Model {
        id: 1,
        name: "Orange".to_owned(),
        cake_id: None,
    }
);

assert_eq!(
    db.into_transaction_log(),
    [
        Transaction::from_sql_and_values(
            DbBackend::MySql,
            r#"UPDATE `fruit` SET `name` = ? WHERE `fruit`.`id` = ?"#,
            ["Orange".into(), 1i32.into()]
        ),
        Transaction::from_sql_and_values(
            DbBackend::MySql,
            r#"SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit` WHERE `fruit`.`id` = ? LIMIT ?"#,
            [1i32.into(), 1u64.into()]
        )]);

fn save<'a, 'async_trait, C>( self, db: &'a C, ) -> Pin<Box<dyn Future<Output = Result<Self, DbErr>> + Send + 'async_trait>>

where <Self::Entity as EntityTrait>::Model: IntoActiveModel<Self>, Self: ActiveModelBehavior + Send + 'async_trait, C: ConnectionTrait + 'async_trait, 'a: 'async_trait,

Insert the model if primary key is NotSet, update otherwise. Only works if the entity has auto increment primary key.

fn delete<'a, 'async_trait, C>( self, db: &'a C, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult, DbErr>> + Send + 'async_trait>>

where Self: ActiveModelBehavior + Send + 'async_trait, C: ConnectionTrait + 'async_trait, 'a: 'async_trait,

Delete an active model by its primary key

Example

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

let orange = fruit::ActiveModel {
    id: Set(3),
    ..Default::default()
};

let delete_result = orange.delete(&db).await?;

assert_eq!(delete_result.rows_affected, 1);

assert_eq!(
    db.into_transaction_log(),
    [Transaction::from_sql_and_values(
        DbBackend::Postgres,
        r#"DELETE FROM "fruit" WHERE "fruit"."id" = $1"#,
        [3i32.into()]
    )]
);

fn set_from_json(&mut self, json: Value) -> Result<(), DbErr>

where Self: TryIntoModel<<Self::Entity as EntityTrait>::Model>, for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> + Serialize,

Set the corresponding attributes in the ActiveModel from a JSON value

Note that this method will not alter the primary key values in ActiveModel.

fn from_json(json: Value) -> Result<Self, DbErr>

where Self: TryIntoModel<<Self::Entity as EntityTrait>::Model>, for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> + Serialize,

Create ActiveModel from a JSON value

fn is_changed(&self) -> bool

Return true if any attribute of ActiveModel is Set

fn find_related<R>(&self, _: R) -> Select<R>

where R: EntityTrait, Self::Entity: Related<R>,

Find related Models belonging to self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors