Trait sea_orm::entity::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(&mut self, c: <Self::Entity as EntityTrait>::Column, v: 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 reset(&mut self, c: <Self::Entity as EntityTrait>::Column);

    // Provided methods
    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 set(&mut self, c: <Self::Entity as EntityTrait>::Column, v: Value)

Set the Value into 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

The default implementation of the ActiveModel

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 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>,

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>,

Create ActiveModel from a JSON value

fn is_changed(&self) -> bool

Return true if any attribute of ActiveModel is Set

Object Safety

This trait is not object safe.

Implementors