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

Create an ActiveValue::Set

pub fn is_set(&self) -> bool

Check if the ActiveValue is ActiveValue::Set

pub fn unchanged(value: V) -> ActiveValue<V>

Create an ActiveValue::Unchanged

pub fn is_unchanged(&self) -> bool

Check if the ActiveValue is ActiveValue::Unchanged

pub fn not_set() -> ActiveValue<V>

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.

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

impl<V> Clone for ActiveValue<V>

where V: Clone + Into<Value>,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for ActiveValue<V>

where V: Debug + Into<Value>,

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

Formats the value using the given formatter.

impl<V> Default for ActiveValue<V>

where V: Into<Value>,

fn default() -> ActiveValue<V>

Create an ActiveValue::NotSet

impl<V> From<ActiveValue<V>> for ActiveValue<Option<V>>

where V: Into<Value> + Nullable,

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

Converts to this type from the input type.

impl<V> PartialEq for ActiveValue<V>

where V: Into<Value> + PartialEq,

fn eq(&self, other: &ActiveValue<V>) -> 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.