Enum Passive 

pub enum Passive<T: AsValue> {
    Set(T),
    NotSet,
}

Wrapper marking whether a column should be considered set or skipped (passive) on INSERT.

Variants

Set(T)

Active value.

NotSet

Skip during value emission (DEFAULT used by SqlWriter).

Implementations

impl<T: AsValue> Passive<T>

pub fn new(value: T) -> Self

pub fn expect(self, msg: &str) -> T

pub fn unwrap(self) -> T

Trait Implementations

impl<T: AsValue> AsValue for Passive<T>

fn as_empty_value() -> Value

Return an “empty” (NULL-like) value variant for this type. Used when constructing composite Value containers (arrays, maps) or representing absent optional data. This should never allocate and should not rely on default trait implementations of Self.

fn as_value(self) -> Value

Convert this value into its owned Value representation. This should perform any necessary wrapping (e.g. collections into List, decimals into Decimal) but avoid lossy transformations unless explicitly documented.

fn try_from_value(value: Value) -> Result<Self>

Attempt to convert a dynamic Value into Self.

fn parse(input: impl AsRef<str>) -> Result<Self>

where Self: Sized,

Parse a full string into Self delegating to [AsValue::extract].

impl<T> Clone for Passive<T>

where T: Clone + AsValue,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AsValue> Debug for Passive<T>

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

Formats the value using the given formatter.

impl<T: AsValue> Default for Passive<T>

fn default() -> Passive<T>

Returns the “default value” for a type.

impl<T: AsValue> From<T> for Passive<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash + AsValue> Hash for Passive<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + AsValue> PartialEq for Passive<T>

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.

impl<T: Eq + AsValue> Eq for Passive<T>