Enum dynamodb_expression::condition::Condition

pub enum Condition {
    AttributeExists(AttributeExists),
    AttributeNotExists(AttributeNotExists),
    AttributeType(AttributeType),
    BeginsWith(BeginsWith),
    Between(Between),
    Contains(Contains),
    In(In),
    Not(Not),
    And(And),
    Or(Or),
    Comparison(Comparison),
    Parenthetical(Parenthetical),
}

Represents a logical condition in a DynamoDB expression.

You will usually create these using the methods on Path.

Variants

AttributeExists(AttributeExists)

AttributeNotExists(AttributeNotExists)

AttributeType(AttributeType)

BeginsWith(BeginsWith)

Between(Between)

Contains(Contains)

In(In)

Not(Not)

And(And)

Or(Or)

Comparison(Comparison)

Parenthetical(Parenthetical)

Implementations

impl Condition

pub fn and<R>(self, right: R) -> Selfwhere R: Into<Condition>,

A DynamoDB logical AND condition.

use dynamodb_expression::Path;

let a = Path::new_name("a");
let b = Path::new_name("b");
let c = Path::new_name("c");
let d = Path::new_name("d");

let condition = a.greater_than(b).and(c.less_than(d));
assert_eq!("a > b AND c < d", condition.to_string());

pub fn or<R>(self, right: R) -> Selfwhere R: Into<Condition>,

A DynamoDB logical OR condition.

use dynamodb_expression::Path;

let a = Path::new_name("a");
let b = Path::new_name("b");
let c = Path::new_name("c");
let d = Path::new_name("d");

let condition = a.greater_than(b).or(c.less_than(d));
assert_eq!("a > b OR c < d", condition.to_string());

pub fn not(self) -> Self

A DynamoDB logical NOT condition.

use dynamodb_expression::Path;

let a = Path::new_name("a");
let b = Path::new_name("b");

let condition = a.greater_than(b).not();
assert_eq!("NOT a > b", condition.to_string());

pub fn parenthesize(self) -> Self

Wraps a condition in parentheses.

use dynamodb_expression::Path;

let a = Path::new_name("a");
let b = Path::new_name("b");
let c = Path::new_name("c");
let d = Path::new_name("d");

let condition = a.greater_than(b).parenthesize().and(c.less_than(d).parenthesize());
assert_eq!("(a > b) AND (c < d)", condition.to_string());

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl Display for Condition

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

Formats the value using the given formatter.

impl From<And> for Condition

fn from(condition: And) -> Self

Converts to this type from the input type.

impl From<AttributeExists> for Condition

fn from(condition: AttributeExists) -> Self

Converts to this type from the input type.

impl From<AttributeNotExists> for Condition

fn from(condition: AttributeNotExists) -> Self

Converts to this type from the input type.

impl From<AttributeType> for Condition

fn from(condition: AttributeType) -> Self

Converts to this type from the input type.

impl From<BeginsWith> for Condition

fn from(condition: BeginsWith) -> Self

Converts to this type from the input type.

impl From<Between> for Condition

fn from(condition: Between) -> Self

Converts to this type from the input type.

impl From<Comparison> for Condition

fn from(condition: Comparison) -> Self

Converts to this type from the input type.

impl From<Condition> for String

fn from(condition: Condition) -> Self

Converts to this type from the input type.

impl From<Contains> for Condition

fn from(condition: Contains) -> Self

Converts to this type from the input type.

impl From<In> for Condition

fn from(condition: In) -> Self

Converts to this type from the input type.

impl From<Not> for Condition

fn from(condition: Not) -> Self

Converts to this type from the input type.

impl From<Or> for Condition

fn from(condition: Or) -> Self

Converts to this type from the input type.

impl From<Parenthetical> for Condition

fn from(condition: Parenthetical) -> Self

Converts to this type from the input type.

impl Not for Condition

fn not(self) -> Self::Output

A DynamoDB logical NOT condition.

use dynamodb_expression::Path;

let a = Path::new_name("a");
let b = Path::new_name("b");

let condition = !a.greater_than(b);
assert_eq!("NOT a > b", condition.to_string());

type Output = Condition

The resulting type after applying the ! operator.

impl PartialEq for Condition

fn eq(&self, other: &Condition) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Condition

impl StructuralEq for Condition

impl StructuralPartialEq for Condition