Struct dynamodb_expression::update::list_append::Builder

pub struct Builder { /* private fields */ }

Builds an ListAppend instance.

See also: Path::list_append

Implementations

impl Builder

pub fn src<T>(self, src: T) -> Self

where T: Into<Path>,

Sets the source Path to read the initial list from.

Defaults to the Path the combined list is being assigned to.

let list_append = "foo"
    .parse::<Path>()?
    .list_append()
    .src("bar".parse::<Path>()?)
    .list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(bar, [1, 2, 3])", list_append.to_string());

Compare with what happens without specifying a source Path:

let list_append = "foo"
    .parse::<Path>()?
    .list_append()
    .list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(foo, [1, 2, 3])", list_append.to_string());

pub fn after(self) -> Self

The new values will be appended to the end of the existing values.

This is the default.

let list_append = "foo".parse::<Path>()?.list_append().after().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(foo, [1, 2, 3])", list_append.to_string());

Compare with when before is used:

let list_append = "foo".parse::<Path>()?.list_append().before().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append([1, 2, 3], foo)", list_append.to_string());

The default, with the same behavior as after:

let list_append = "foo".parse::<Path>()?.list_append().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(foo, [1, 2, 3])", list_append.to_string());

pub fn before(self) -> Self

The new values will be placed before the existing values.

Defaults to appending new values after existing values.

let list_append = "foo".parse::<Path>()?.list_append().before().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append([1, 2, 3], foo)", list_append.to_string());

Compare with when after is used:

let list_append = "foo".parse::<Path>()?.list_append().after().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(foo, [1, 2, 3])", list_append.to_string());

The default, with the same behavior as after:

let list_append = "foo".parse::<Path>()?.list_append().list([1, 2, 3].map(Num::new));
assert_eq!("foo = list_append(foo, [1, 2, 3])", list_append.to_string());

pub fn list<T>(self, list: T) -> ListAppend

where T: Into<List>,

Sets the new value(s) to concatenate with the specified field.

Consumes this Builder and creates a ListAppend instance.

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Builder

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

Formats the value using the given formatter.