Enum 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) -> Self

where R: Into<Condition>,

A DynamoDB logical AND condition.

See also: And

use dynamodb_expression::Path;

let a = "a".parse::<Path>()?;
let b = "b".parse::<Path>()?;
let c = "c".parse::<Path>()?;
let d = "d".parse::<Path>()?;

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) -> Self

where R: Into<Condition>,

A DynamoDB logical OR condition.

See also: Or

use dynamodb_expression::Path;

let a = "a".parse::<Path>()?;
let b = "b".parse::<Path>()?;
let c = "c".parse::<Path>()?;
let d = "d".parse::<Path>()?;

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.

See also: Not

use dynamodb_expression::Path;

let a = "a".parse::<Path>()?;
let b = "b".parse::<Path>()?;

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.

See also: Parenthetical

use dynamodb_expression::Path;

let a = "a".parse::<Path>()?;
let b = "b".parse::<Path>()?;
let c = "c".parse::<Path>()?;
let d = "d".parse::<Path>()?;

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) -> Self

Returns a duplicate 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 Eq for Condition

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.

See also: Condition::not, Not

use dynamodb_expression::Path;

let a = "a".parse::<Path>()?;
let b = "b".parse::<Path>()?;

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Condition