Struct dynamodb_expression::Builder

pub struct Builder { /* private fields */ }

For building an Expression. Finish with .build().

See: Expression::builder

Implementations

impl Builder

Functions and methods for building an Expression.

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

where T: Into<Condition>,

Sets the condition for this Expression, overwriting any previously set.

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

where T: Into<KeyCondition>,

Sets the key condition for this Expression, overwriting any previously set.

See also: Path::key

use dynamodb_expression::{Expression, Num, Path};

let key_condition = "id"
    .parse::<Path>()?
    .key()
    .equal(Num::new(42))
    .and("category".parse::<Path>()?.key().begins_with("hardware."));

let expression = Expression::builder().with_key_condition(key_condition).build();

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

where T: Into<Update>,

Sets the update expression, overwriting any previously set.

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

where T: Into<Condition>,

Sets the filter for this Expression, overwriting any previously set.

pub fn with_projection<I, T>(self, names: I) -> Self

where I: IntoIterator<Item = T>, T: Into<Name>,

Sets the projection for this Expression, overwriting any previously set.

Each of these examples produce the same projection expression.

let expected = Expression {
    condition_expression: None,
    key_condition_expression: None,
    update_expression: None,
    filter_expression: None,
    projection_expression: Some(String::from("#0, #1")),
    expression_attribute_names: Some(
        [("#0", "id"), ("#1", "name")]
            .into_iter()
            .map(|(k, v)| (String::from(k), String::from(v)))
            .collect(),
    ),
    expression_attribute_values: None,
};

let expression = Expression::builder()
    .with_projection(["id", "name"])
    .build();
assert_eq!(expected, expression);

let expression = Expression::builder()
    .with_projection([String::from("id"), String::from("name")])
    .build();
assert_eq!(expected, expression);

let expression = Expression::builder()
    .with_projection([Name::from("id"), Name::from("name")])
    .build();
assert_eq!(expected, expression);

// Anything that's `IntoIterator` will work. A `Vec`, for example.
let expression = Expression::builder()
    .with_projection(vec!["id", "name"])
    .build();
assert_eq!(expected, expression);

// Or an `Iterator`.
let expression = Expression::builder()
    .with_projection(["id", "name"].into_iter().map(Name::from))
    .build();
assert_eq!(expected, expression);

pub fn build(self) -> Expression

Builds the Expression.

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.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.