Enum 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

Panics

Panics if it is ActiveValue::NotSet

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

Check if a Value exists or not

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

Wrap the Value into a ActiveValue<Value>

pub fn reset(&mut self)

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

pub fn set_if_not_equals(&mut self, value: V)

where V: PartialEq,

Set(value), except when self.is_unchanged() and value equals the current Unchanged value.

This is useful when you have an Unchanged value from the database, then update it using this method, and then use .is_unchanged() to see whether it has actually changed.

The same nice effect applies to the entire ActiveModel. You can now meaningfully use ActiveModelTrait::is_changed to see whether are any changes that need to be saved to the database.

Examples

let mut value = ActiveValue::Unchanged("old");

// This wouldn't be the case if we used plain `value = Set("old");`
value.set_if_not_equals("old");
assert!(value.is_unchanged());

// Only when we change the actual `&str` value, it becomes `Set`
value.set_if_not_equals("new");
assert_eq!(value.is_unchanged(), false);
assert_eq!(value, ActiveValue::Set("new"));

pub fn try_as_ref(&self) -> Option<&V>

Get the inner value, unless self is NotSet.

There’s also a panicking version: ActiveValue::as_ref.

Examples

assert_eq!(ActiveValue::Unchanged(42).try_as_ref(), Some(&42));
assert_eq!(ActiveValue::Set(42).try_as_ref(), Some(&42));
assert_eq!(ActiveValue::NotSet.try_as_ref(), None::<&i32>);

Trait Implementations

impl<V> AsRef<V> for ActiveValue<V>

where V: Into<Value>,

fn as_ref(&self) -> &V

Panics

Panics if it is ActiveValue::NotSet.

See ActiveValue::try_as_ref for a fallible non-panicking version.

impl<V> Clone for ActiveValue<V>

where V: Into<Value> + Clone,

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 for ActiveValue<V>

where V: Into<Value> + Debug,

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 for ActiveValue<V>

where V: Into<Value> + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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