Enum Assignment 

pub enum Assignment {
    Set(Expr),
    Insert(Expr),
    Remove(Expr),
    Append(Expr),
    Pop,
    RemoveAt(Expr),
    Batch(Vec<Assignment>),
}

A field assignment within an Update statement.

Each variant carries the expression providing the value for the operation. Multiple operations on the same field are represented via Batch.

Examples

use toasty_core::stmt::{Assignment, Expr};

let assignment = Assignment::Set(Expr::null());
assert!(assignment.is_set());

Variants

Set(Expr)

Set a field, replacing the current value.

Insert(Expr)

Insert one or more values into a set field.

Remove(Expr)

Remove one or more values from a set field.

Append(Expr)

Append every element of a list expression to the end of an ordered collection field (e.g. Vec<scalar>). The expression must evaluate to a list whose element type matches the target column.

Pop

Drop the last element of an ordered collection field. Drives stmt::pop on Vec<scalar> fields. No-op on an empty collection.

RemoveAt(Expr)

Drop the element at the given index from an ordered collection field. The expression must evaluate to a usize-shaped value. Out-of-bounds indices are a no-op rather than an error — per-row failure semantics on a bulk update are rarely useful.

Batch(Vec<Assignment>)

Multiple assignments on the same field.

Implementations

impl Assignment

pub fn is_set(&self) -> bool

Returns true if this is the Set variant.

pub fn is_remove(&self) -> bool

Returns true if this is the Remove variant.

pub fn push(&mut self, other: Assignment)

Appends another assignment, converting to Batch if needed.

Trait Implementations

impl Clone for Assignment

fn clone(&self) -> Assignment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Assignment

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

Formats the value using the given formatter.

impl Node for Assignment

fn visit<V>(&self, visit: V)

where V: Visit,

Traverses this node with an immutable visitor.

fn visit_mut<V>(&mut self, visit: V)

where V: VisitMut,

Traverses this node with a mutable visitor.

impl PartialEq for Assignment

fn eq(&self, other: &Assignment) -> 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 StructuralPartialEq for Assignment