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

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: &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