Struct rusoto_ce::Expression

pub struct Expression {
    pub and: Option<Vec<Expression>>,
    pub cost_categories: Option<CostCategoryValues>,
    pub dimensions: Option<DimensionValues>,
    pub not: Box<Option<Expression>>,
    pub or: Option<Vec<Expression>>,
    pub tags: Option<TagValues>,
}

Use Expression to filter by cost or by usage. There are two patterns:

• Simple dimension values - You can set the dimension name and values for the filters that you plan to use. For example, you can filter for REGION==us-east-1 OR REGION==us-west-1. For GetRightsizingRecommendation, the Region is a full name (for example, REGION==US East (N. Virginia). The Expression example looks like:

  { "Dimensions": { "Key": "REGION", "Values": [ "us-east-1", “us-west-1” ] } }

  The list of dimension values are OR'd together to retrieve cost or usage data. You can create Expression and DimensionValues objects using either with methods or set methods in multiple lines.

• Compound dimension values with logical operations - You can use multiple Expression types and the logical operators AND/OR/NOT to create a list of one or more Expression objects. This allows you to filter on more advanced options. For example, you can filter on ((REGION == us-east-1 OR REGION == us-west-1) OR (TAG.Type == Type1)) AND (USAGETYPE != DataTransfer). The Expression for that looks like this:

  { "And": [ {"Or": [ {"Dimensions": { "Key": "REGION", "Values": [ "us-east-1", "us-west-1" ] }}, {"Tags": { "Key": "TagName", "Values": ["Value1"] } } ]}, {"Not": {"Dimensions": { "Key": "USAGETYPE", "Values": ["DataTransfer"] }}} ] }

  Because each Expression can have only one operator, the service returns an error if more than one is specified. The following example shows an Expression object that creates an error.

  { "And": [ ... ], "DimensionValues": { "Dimension": "USAGETYPE", "Values": [ "DataTransfer" ] } }

For the GetRightsizingRecommendation action, a combination of OR and NOT is not supported. OR is not supported between different dimensions, or dimensions and tags. NOT operators aren't supported. Dimensions are also limited to LINKEDACCOUNT, REGION, or RIGHTSIZINGTYPE.

For the GetReservationPurchaseRecommendation action, only NOT is supported. AND and OR are not supported. Dimensions are limited to LINKEDACCOUNT.

Fields

and: Option<Vec<Expression>>

Return results that match both Dimension objects.

cost_categories: Option<CostCategoryValues>

The filter based on CostCategory values.

dimensions: Option<DimensionValues>

The specific Dimension to use for Expression.

not: Box<Option<Expression>>

Return results that don't match a Dimension object.

or: Option<Vec<Expression>>

Return results that match either Dimension object.

tags: Option<TagValues>

The specific Tag to use for Expression.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Expression

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Expression> for Expression

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

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

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

This method tests for !=.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression