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 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 try_set(
        &mut self,
        c: <Self::Entity as EntityTrait>::Column,
        v: Value,
    ) -> Result<(), DbErr> { ... }
    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 + 'a + 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 + 'a + 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 + 'a + 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 + 'a + Send + 'async_trait,
             C: ConnectionTrait + 'async_trait,
             'a: 'async_trait { ... }
    fn set_from_json(&mut self, json: Value) -> Result<(), DbErr>
       where for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> { ... }
    fn from_json(json: Value) -> Result<Self, DbErr>
       where for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de> { ... }
    fn is_changed(&self) -> bool { ... }
}

A Trait for ActiveModel to perform Create, Update or Delete operation. The type must also implement the EntityTrait. See module level docs crate::entity for a full example

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 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 into an ActiveModel, panic if failed

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

Set the Value into an ActiveModel, return error if failed.

This method is provided to prevent breaking changes, will be removed in next major version. The provided implementation will still panic.

If you’re using DeriveActiveModel then it’s correctly implemented.

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

Panics

Panics if arity of primary key exceed maximum arity of 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 + 'a + 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 + 'a + 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 + 'a + 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 + 'a + 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 for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de>,

Available on crate feature with-json only.

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 for<'de> <<Self as ActiveModelTrait>::Entity as EntityTrait>::Model: IntoActiveModel<Self> + Deserialize<'de>,

Available on crate feature with-json only.

Create ActiveModel from a JSON value

fn is_changed(&self) -> bool

Return true if any attribute of ActiveModel is Set

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