Enum sea_orm::entity::ActiveValue

pub enum ActiveValue<V>where
    V: Into<Value>,{
    Set(V),
    Unchanged(V),
    NotSet,
}

Defines a stateful value used in ActiveModel.

There are three possible state represented by three enum variants.

• ActiveValue::Set: A defined Value actively being set
• ActiveValue::Unchanged: A defined Value remain unchanged
• ActiveValue::NotSet: An undefined Value

The stateful value is useful when constructing UPDATE SQL statement, see an example below.

Examples

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

// The code snipped below does an UPDATE operation on a `ActiveValue`
assert_eq!(
    Update::one(fruit::ActiveModel {
        id: ActiveValue::set(1),
        name: ActiveValue::set("Orange".to_owned()),
        cake_id: ActiveValue::not_set(),
    })
    .build(DbBackend::Postgres)
    .to_string(),
    r#"UPDATE "fruit" SET "name" = 'Orange' WHERE "fruit"."id" = 1"#
);

Variants

Set(V)

A defined Value actively being set

Unchanged(V)

A defined Value remain unchanged

NotSet

An undefined Value

Implementations

impl<V> ActiveValue<V>where
    V: Into<Value>,

pub fn set(value: V) -> Self

Create an ActiveValue::Set

pub fn is_set(&self) -> bool

Check if the ActiveValue is ActiveValue::Set

pub fn unchanged(value: V) -> Self

Create an ActiveValue::Unchanged

pub fn is_unchanged(&self) -> bool

Check if the ActiveValue is ActiveValue::Unchanged

pub fn not_set() -> Self

Create an ActiveValue::NotSet

pub fn is_not_set(&self) -> bool

Check if the ActiveValue is ActiveValue::NotSet

pub fn take(&mut self) -> Option<V>

Get the mutable value an ActiveValue also setting itself to ActiveValue::NotSet

pub fn unwrap(self) -> V

Get an owned value of the ActiveValue

pub fn into_value(self) -> Option<Value>

Check is a Value exists or not

pub fn into_wrapped_value(self) -> ActiveValue<Value>

Wrap the Value into a ActiveValue<Value>

Trait Implementations

impl<V> AsRef<V> for ActiveValue<V>where
    V: Into<Value>,

fn as_ref(&self) -> &V

Converts this type into a shared reference of the (usually inferred) input type.

impl<V: Clone> Clone for ActiveValue<V>where
    V: Into<Value>,

fn clone(&self) -> ActiveValue<V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for ActiveValue<V>where
    V: Into<Value>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V> Default for ActiveValue<V>where
    V: Into<Value>,

fn default() -> Self

Create an ActiveValue::NotSet

impl<V> From<ActiveValue<V>> for ActiveValue<Option<V>>where
    V: Into<Value> + Nullable,

fn from(value: ActiveValue<V>) -> Self

Converts to this type from the input type.

impl<V> PartialEq<ActiveValue<V>> for ActiveValue<V>where
    V: Into<Value> + PartialEq,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.