github.com/aavshr/aws-sdk-go@v1.41.3/service/dynamodb/expression/condition.go

package expression

import (
	"fmt"
	"strings"
)

// conditionMode specifies the types of the struct conditionBuilder,
// representing the different types of Conditions (i.e. And, Or, Between, ...)
type conditionMode int

const (
	// unsetCond catches errors for unset ConditionBuilder structs
	unsetCond conditionMode = iota
	// equalCond represents the Equals Condition
	equalCond
	// notEqualCond represents the Not Equals Condition
	notEqualCond
	// lessThanCond represents the LessThan Condition
	lessThanCond
	// lessThanEqualCond represents the LessThanOrEqual Condition
	lessThanEqualCond
	// greaterThanCond represents the GreaterThan Condition
	greaterThanCond
	// greaterThanEqualCond represents the GreaterThanEqual Condition
	greaterThanEqualCond
	// andCond represents the Logical And Condition
	andCond
	// orCond represents the Logical Or Condition
	orCond
	// notCond represents the Logical Not Condition
	notCond
	// betweenCond represents the Between Condition
	betweenCond
	// inCond represents the In Condition
	inCond
	// attrExistsCond represents the Attribute Exists Condition
	attrExistsCond
	// attrNotExistsCond represents the Attribute Not Exists Condition
	attrNotExistsCond
	// attrTypeCond represents the Attribute Type Condition
	attrTypeCond
	// beginsWithCond represents the Begins With Condition
	beginsWithCond
	// containsCond represents the Contains Condition
	containsCond
)

// DynamoDBAttributeType specifies the type of an DynamoDB item attribute. This
// enum is used in the AttributeType() function in order to be explicit about
// the DynamoDB type that is being checked and ensure compile time checks.
// More Informatin at http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions
type DynamoDBAttributeType string

const (
	// String represents the DynamoDB String type
	String DynamoDBAttributeType = "S"
	// StringSet represents the DynamoDB String Set type
	StringSet = "SS"
	// Number represents the DynamoDB Number type
	Number = "N"
	// NumberSet represents the DynamoDB Number Set type
	NumberSet = "NS"
	// Binary represents the DynamoDB Binary type
	Binary = "B"
	// BinarySet represents the DynamoDB Binary Set type
	BinarySet = "BS"
	// Boolean represents the DynamoDB Boolean type
	Boolean = "BOOL"
	// Null represents the DynamoDB Null type
	Null = "NULL"
	// List represents the DynamoDB List type
	List = "L"
	// Map represents the DynamoDB Map type
	Map = "M"
)

// ConditionBuilder represents Condition Expressions and Filter Expressions
// in DynamoDB. ConditionBuilders are one of the building blocks of the Builder
// struct. Since Filter Expressions support all the same functions and formats
// as Condition Expressions, ConditionBuilders represents both types of
// Expressions.
// More Information at: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html
// More Information on Filter Expressions: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.FilterExpression
type ConditionBuilder struct {
	operandList   []OperandBuilder
	conditionList []ConditionBuilder
	mode          conditionMode
}

// Equal returns a ConditionBuilder representing the equality clause of the two
// argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the equal clause of the item attribute "foo" and
//     // the value 5
//     condition := expression.Equal(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Equal(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo = :five"
func Equal(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        equalCond,
	}
}

// Equal returns a ConditionBuilder representing the equality clause of the two
// argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the equal clause of the item attribute "foo" and
//     // the value 5
//     condition := expression.Name("foo").Equal(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").Equal(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo = :five"
func (nb NameBuilder) Equal(right OperandBuilder) ConditionBuilder {
	return Equal(nb, right)
}

// Equal returns a ConditionBuilder representing the equality clause of the two
// argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the equal clause of the item attribute "foo" and
//     // the value 5
//     condition := expression.Value(5).Equal(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).Equal(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five = foo"
func (vb ValueBuilder) Equal(right OperandBuilder) ConditionBuilder {
	return Equal(vb, right)
}

// Equal returns a ConditionBuilder representing the equality clause of the two
// argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the equal clause of the size of the item
//     // attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).Equal(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).Equal(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) = :five"
func (sb SizeBuilder) Equal(right OperandBuilder) ConditionBuilder {
	return Equal(sb, right)
}

// NotEqual returns a ConditionBuilder representing the not equal clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the not equal clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.NotEqual(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.NotEqual(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo <> :five"
func NotEqual(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        notEqualCond,
	}
}

// NotEqual returns a ConditionBuilder representing the not equal clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the not equal clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.Name("foo").NotEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").NotEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo <> :five"
func (nb NameBuilder) NotEqual(right OperandBuilder) ConditionBuilder {
	return NotEqual(nb, right)
}

// NotEqual returns a ConditionBuilder representing the not equal clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the not equal clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.Value(5).NotEqual(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).NotEqual(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five <> foo"
func (vb ValueBuilder) NotEqual(right OperandBuilder) ConditionBuilder {
	return NotEqual(vb, right)
}

// NotEqual returns a ConditionBuilder representing the not equal clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the not equal clause of the size of the item
//     // attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).NotEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).NotEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) <> :five"
func (sb SizeBuilder) NotEqual(right OperandBuilder) ConditionBuilder {
	return NotEqual(sb, right)
}

// LessThan returns a ConditionBuilder representing the less than clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the less than clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.LessThan(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.LessThan(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo < :five"
func LessThan(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        lessThanCond,
	}
}

// LessThan returns a ConditionBuilder representing the less than clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the less than clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.Name("foo").LessThan(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").LessThan(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo < :five"
func (nb NameBuilder) LessThan(right OperandBuilder) ConditionBuilder {
	return LessThan(nb, right)
}

// LessThan returns a ConditionBuilder representing the less than clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the less than clause of the item attribute "foo"
//     // and the value 5
//     condition := expression.Value(5).LessThan(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).LessThan(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five < foo"
func (vb ValueBuilder) LessThan(right OperandBuilder) ConditionBuilder {
	return LessThan(vb, right)
}

// LessThan returns a ConditionBuilder representing the less than clause of the
// two argument OperandBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the less than clause of the size of the item
//     // attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).LessThan(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).LessThan(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) < :five"
func (sb SizeBuilder) LessThan(right OperandBuilder) ConditionBuilder {
	return LessThan(sb, right)
}

// LessThanEqual returns a ConditionBuilder representing the less than equal to
// clause of the two argument OperandBuilders. The resulting ConditionBuilder
// can be used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the less than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.LessThanEqual(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.LessThanEqual(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo <= :five"
func LessThanEqual(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        lessThanEqualCond,
	}
}

// LessThanEqual returns a ConditionBuilder representing the less than equal to
// clause of the two argument OperandBuilders. The resulting ConditionBuilder
// can be used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the less than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.Name("foo").LessThanEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").LessThanEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo <= :five"
func (nb NameBuilder) LessThanEqual(right OperandBuilder) ConditionBuilder {
	return LessThanEqual(nb, right)
}

// LessThanEqual returns a ConditionBuilder representing the less than equal to
// clause of the two argument OperandBuilders. The resulting ConditionBuilder
// can be used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the less than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.Value(5).LessThanEqual(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).LessThanEqual(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five <= foo"
func (vb ValueBuilder) LessThanEqual(right OperandBuilder) ConditionBuilder {
	return LessThanEqual(vb, right)
}

// LessThanEqual returns a ConditionBuilder representing the less than equal to
// clause of the two argument OperandBuilders. The resulting ConditionBuilder
// can be used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the less than equal to clause of the size of the
//     // item attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).LessThanEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).LessThanEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) <= :five"
func (sb SizeBuilder) LessThanEqual(right OperandBuilder) ConditionBuilder {
	return LessThanEqual(sb, right)
}

// GreaterThan returns a ConditionBuilder representing the greater than clause
// of the two argument OperandBuilders. The resulting ConditionBuilder can be
// used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than clause of the item attribute
//     // "foo" and the value 5
//     condition := expression.GreaterThan(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.GreaterThan(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo > :five"
func GreaterThan(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        greaterThanCond,
	}
}

// GreaterThan returns a ConditionBuilder representing the greater than clause
// of the two argument OperandBuilders. The resulting ConditionBuilder can be
// used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than clause of the item attribute
//     // "foo" and the value 5
//     condition := expression.Name("foo").GreaterThan(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").GreaterThan(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo > :five"
func (nb NameBuilder) GreaterThan(right OperandBuilder) ConditionBuilder {
	return GreaterThan(nb, right)
}

// GreaterThan returns a ConditionBuilder representing the greater than clause
// of the two argument OperandBuilders. The resulting ConditionBuilder can be
// used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than clause of the item attribute
//     // "foo" and the value 5
//     condition := expression.Value(5).GreaterThan(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).GreaterThan(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five > foo"
func (vb ValueBuilder) GreaterThan(right OperandBuilder) ConditionBuilder {
	return GreaterThan(vb, right)
}

// GreaterThan returns a ConditionBuilder representing the greater than
// clause of the two argument OperandBuilders. The resulting ConditionBuilder
// can be used as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than clause of the size of the item
//     // attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).GreaterThan(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).GreaterThan(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) > :five"
func (sb SizeBuilder) GreaterThan(right OperandBuilder) ConditionBuilder {
	return GreaterThan(sb, right)
}

// GreaterThanEqual returns a ConditionBuilder representing the greater than
// equal to clause of the two argument OperandBuilders. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.GreaterThanEqual(expression.Name("foo"), expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.GreaterThanEqual(expression.Name("foo"), expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo >= :five"
func GreaterThanEqual(left, right OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{left, right},
		mode:        greaterThanEqualCond,
	}
}

// GreaterThanEqual returns a ConditionBuilder representing the greater than
// equal to clause of the two argument OperandBuilders. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.Name("foo").GreaterThanEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("foo").GreaterThanEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "foo >= :five"
func (nb NameBuilder) GreaterThanEqual(right OperandBuilder) ConditionBuilder {
	return GreaterThanEqual(nb, right)
}

// GreaterThanEqual returns a ConditionBuilder representing the greater than
// equal to clause of the two argument OperandBuilders. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than equal to clause of the item
//     // attribute "foo" and the value 5
//     condition := expression.Value(5).GreaterThanEqual(expression.Name("foo"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(5).GreaterThanEqual(expression.Name("foo"))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     ":five >= foo"
func (vb ValueBuilder) GreaterThanEqual(right OperandBuilder) ConditionBuilder {
	return GreaterThanEqual(vb, right)
}

// GreaterThanEqual returns a ConditionBuilder representing the greater than
// equal to clause of the two argument OperandBuilders. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the greater than equal to clause of the size of
//     // the item attribute "foo" and the value 5
//     condition := expression.Size(expression.Name("foo")).GreaterThanEqual(expression.Value(5))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("foo")).GreaterThanEqual(expression.Value(5))
//     // Let :five be an ExpressionAttributeValue representing the value 5
//     "size (foo) >= :five"
func (sb SizeBuilder) GreaterThanEqual(right OperandBuilder) ConditionBuilder {
	return GreaterThanEqual(sb, right)
}

// And returns a ConditionBuilder representing the logical AND clause of the
// argument ConditionBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct. Note that And() can take a variadic number of
// ConditionBuilders as arguments.
//
// Example:
//
//     // condition represents the condition where the item attribute "Name" is
//     // equal to value "Generic Name" AND the item attribute "Age" is less
//     // than value 40
//     condition := expression.And(expression.Name("Name").Equal(expression.Value("Generic Name")), expression.Name("Age").LessThan(expression.Value(40)))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.And(expression.Name("Name").Equal(expression.Value("Generic Name")), expression.Name("Age").LessThan(expression.Value(40)))
//     // Let #NAME, :name, and :forty be ExpressionAttributeName and
//     // ExpressionAttributeValues representing the item attribute "Name", the
//     // value "Generic Name", and the value 40
//     "(#NAME = :name) AND (Age < :forty)"
func And(left, right ConditionBuilder, other ...ConditionBuilder) ConditionBuilder {
	other = append([]ConditionBuilder{left, right}, other...)
	return ConditionBuilder{
		conditionList: other,
		mode:          andCond,
	}
}

// And returns a ConditionBuilder representing the logical AND clause of the
// argument ConditionBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct. Note that And() can take a variadic number of
// ConditionBuilders as arguments.
//
// Example:
//
//     // condition represents the condition where the item attribute "Name" is
//     // equal to value "Generic Name" AND the item attribute "Age" is less
//     // than value 40
//     condition := expression.Name("Name").Equal(expression.Value("Generic Name")).And(expression.Name("Age").LessThan(expression.Value(40)))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Name").Equal(expression.Value("Generic Name")).And(expression.Name("Age").LessThan(expression.Value(40)))
//     // Let #NAME, :name, and :forty be ExpressionAttributeName and
//     // ExpressionAttributeValues representing the item attribute "Name", the
//     // value "Generic Name", and the value 40
//     "(#NAME = :name) AND (Age < :forty)"
func (cb ConditionBuilder) And(right ConditionBuilder, other ...ConditionBuilder) ConditionBuilder {
	return And(cb, right, other...)
}

// Or returns a ConditionBuilder representing the logical OR clause of the
// argument ConditionBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct. Note that Or() can take a variadic number of
// ConditionBuilders as arguments.
//
// Example:
//
//     // condition represents the condition where the item attribute "Price" is
//     // less than the value 100 OR the item attribute "Rating" is greater than
//     // the value 8
//     condition := expression.Or(expression.Name("Price").Equal(expression.Value(100)), expression.Name("Rating").LessThan(expression.Value(8)))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Or(expression.Name("Price").Equal(expression.Value(100)), expression.Name("Rating").LessThan(expression.Value(8)))
//     // Let :price and :rating be ExpressionAttributeValues representing the
//     // the value 100 and value 8 respectively
//     "(Price < :price) OR (Rating > :rating)"
func Or(left, right ConditionBuilder, other ...ConditionBuilder) ConditionBuilder {
	other = append([]ConditionBuilder{left, right}, other...)
	return ConditionBuilder{
		conditionList: other,
		mode:          orCond,
	}
}

// Or returns a ConditionBuilder representing the logical OR clause of the
// argument ConditionBuilders. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct. Note that Or() can take a variadic number of
// ConditionBuilders as arguments.
//
// Example:
//
//     // condition represents the condition where the item attribute "Price" is
//     // less than the value 100 OR the item attribute "Rating" is greater than
//     // the value 8
//     condition := expression.Name("Price").Equal(expression.Value(100)).Or(expression.Name("Rating").LessThan(expression.Value(8)))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Price").Equal(expression.Value(100)).Or(expression.Name("Rating").LessThan(expression.Value(8)))
//     // Let :price and :rating be ExpressionAttributeValues representing the
//     // the value 100 and value 8 respectively
//     "(Price < :price) OR (Rating > :rating)"
func (cb ConditionBuilder) Or(right ConditionBuilder, other ...ConditionBuilder) ConditionBuilder {
	return Or(cb, right, other...)
}

// Not returns a ConditionBuilder representing the logical NOT clause of the
// argument ConditionBuilder. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the item attribute "Name"
//     // does not begin with "test"
//     condition := expression.Not(expression.Name("Name").BeginsWith("test"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Not(expression.Name("Name").BeginsWith("test"))
//     // Let :prefix be an ExpressionAttributeValue representing the value
//     // "test"
//     "NOT (begins_with (:prefix))"
func Not(conditionBuilder ConditionBuilder) ConditionBuilder {
	return ConditionBuilder{
		conditionList: []ConditionBuilder{conditionBuilder},
		mode:          notCond,
	}
}

// Not returns a ConditionBuilder representing the logical NOT clause of the
// argument ConditionBuilder. The resulting ConditionBuilder can be used as a
// part of other Condition Expressions or as an argument to the WithCondition()
// method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the item attribute "Name"
//     // does not begin with "test"
//     condition := expression.Name("Name").BeginsWith("test").Not()
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Name").BeginsWith("test").Not()
//     // Let :prefix be an ExpressionAttributeValue representing the value
//     // "test"
//     "NOT (begins_with (:prefix))"
func (cb ConditionBuilder) Not() ConditionBuilder {
	return Not(cb)
}

// Between returns a ConditionBuilder representing the result of the
// BETWEEN function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value of the item
//     // attribute "Rating" is between values 5 and 10
//     condition := expression.Between(expression.Name("Rating"), expression.Value(5), expression.Value(10))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Between(expression.Name("Rating"), expression.Value(5), expression.Value(10))
//     // Let :five and :ten be ExpressionAttributeValues representing the value
//     // 5 and the value 10
//     "Rating BETWEEN :five AND :ten"
func Between(op, lower, upper OperandBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{op, lower, upper},
		mode:        betweenCond,
	}
}

// Between returns a ConditionBuilder representing the result of the
// BETWEEN function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value of the item
//     // attribute "Rating" is between values 5 and 10
//     condition := expression.Name("Rating").Between(expression.Value(5), expression.Value(10))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Rating").Between(expression.Value(5), expression.Value(10))
//     // Let :five and :ten be ExpressionAttributeValues representing the value
//     // 5 and the value 10
//     "Rating BETWEEN :five AND :ten"
func (nb NameBuilder) Between(lower, upper OperandBuilder) ConditionBuilder {
	return Between(nb, lower, upper)
}

// Between returns a ConditionBuilder representing the result of the
// BETWEEN function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value 6 is between values
//     // 5 and 10
//     condition := expression.Value(6).Between(expression.Value(5), expression.Value(10))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value(6).Between(expression.Value(5), expression.Value(10))
//     // Let :six, :five and :ten be ExpressionAttributeValues representing the
//     // values 6, 5, and 10 respectively
//     ":six BETWEEN :five AND :ten"
func (vb ValueBuilder) Between(lower, upper OperandBuilder) ConditionBuilder {
	return Between(vb, lower, upper)
}

// Between returns a ConditionBuilder representing the result of the
// BETWEEN function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the size of the item
//     // attribute "InviteList" is between values 5 and 10
//     condition := expression.Size(expression.Name("InviteList")).Between(expression.Value(5), expression.Value(10))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("InviteList")).Between(expression.Value(5), expression.Value(10))
//     // Let :five and :ten be ExpressionAttributeValues representing the value
//     // 5 and the value 10
//     "size (InviteList) BETWEEN :five AND :ten"
func (sb SizeBuilder) Between(lower, upper OperandBuilder) ConditionBuilder {
	return Between(sb, lower, upper)
}

// In returns a ConditionBuilder representing the result of the IN function
// in DynamoDB Condition Expressions. The resulting ConditionBuilder can be used
// as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value of the item
//     // attribute "Color" is checked against the list of colors "red",
//     // "green", and "blue".
//     condition := expression.In(expression.Name("Color"), expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.In(expression.Name("Color"), expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//     // Let :red, :green, :blue be ExpressionAttributeValues representing the
//     // values "red", "green", and "blue" respectively
//     "Color IN (:red, :green, :blue)"
func In(left, right OperandBuilder, other ...OperandBuilder) ConditionBuilder {
	other = append([]OperandBuilder{left, right}, other...)
	return ConditionBuilder{
		operandList: other,
		mode:        inCond,
	}
}

// In returns a ConditionBuilder representing the result of the IN function
// in DynamoDB Condition Expressions. The resulting ConditionBuilder can be used
// as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value of the item
//     // attribute "Color" is checked against the list of colors "red",
//     // "green", and "blue".
//     condition := expression.Name("Color").In(expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Color").In(expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//     // Let :red, :green, :blue be ExpressionAttributeValues representing the
//     // values "red", "green", and "blue" respectively
//     "Color IN (:red, :green, :blue)"
func (nb NameBuilder) In(right OperandBuilder, other ...OperandBuilder) ConditionBuilder {
	return In(nb, right, other...)
}

// In returns a ConditionBuilder representing the result of the IN function
// TODO change this one
// in DynamoDB Condition Expressions. The resulting ConditionBuilder can be used
// as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the value "yellow" is checked
//     // against the list of colors "red", "green", and "blue".
//     condition := expression.Value("yellow").In(expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Value("yellow").In(expression.Value("red"), expression.Value("green"), expression.Value("blue"))
//     // Let :yellow, :red, :green, :blue be ExpressionAttributeValues
//     // representing the values "yellow", "red", "green", and "blue"
//     // respectively
//     ":yellow IN (:red, :green, :blue)"
func (vb ValueBuilder) In(right OperandBuilder, other ...OperandBuilder) ConditionBuilder {
	return In(vb, right, other...)
}

// In returns a ConditionBuilder representing the result of the IN function
// in DynamoDB Condition Expressions. The resulting ConditionBuilder can be used
// as a part of other Condition Expressions or as an argument to the
// WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the condition where the size of the item
//     // attribute "Donuts" is checked against the list of numbers 12, 24, and
//     // 36.
//     condition := expression.Size(expression.Name("Donuts")).In(expression.Value(12), expression.Value(24), expression.Value(36))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Size(expression.Name("Donuts")).In(expression.Value(12), expression.Value(24), expression.Value(36))
//     // Let :dozen, :twoDozen, :threeDozen be ExpressionAttributeValues
//     // representing the values 12, 24, and 36 respectively
//     "size (Donuts) IN (12, 24, 36)"
func (sb SizeBuilder) In(right OperandBuilder, other ...OperandBuilder) ConditionBuilder {
	return In(sb, right, other...)
}

// AttributeExists returns a ConditionBuilder representing the result of the
// attribute_exists function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" exists or not
//     condition := expression.AttributeExists(expression.Name("Age"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.AttributeExists(expression.Name("Age"))
//     "attribute_exists (Age))"
func AttributeExists(nameBuilder NameBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{nameBuilder},
		mode:        attrExistsCond,
	}
}

// AttributeExists returns a ConditionBuilder representing the result of the
// attribute_exists function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" exists or not
//     condition := expression.Name("Age").AttributeExists()
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Age").AttributeExists()
//     "attribute_exists (Age))"
func (nb NameBuilder) AttributeExists() ConditionBuilder {
	return AttributeExists(nb)
}

// AttributeNotExists returns a ConditionBuilder representing the result of
// the attribute_not_exists function in DynamoDB Condition Expressions. The
// resulting ConditionBuilder can be used as a part of other Condition
// Expressions or as an argument to the WithCondition() method for the Builder
// struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" exists or not
//     condition := expression.AttributeNotExists(expression.Name("Age"))
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.AttributeNotExists(expression.Name("Age"))
//     "attribute_not_exists (Age))"
func AttributeNotExists(nameBuilder NameBuilder) ConditionBuilder {
	return ConditionBuilder{
		operandList: []OperandBuilder{nameBuilder},
		mode:        attrNotExistsCond,
	}
}

// AttributeNotExists returns a ConditionBuilder representing the result of
// the attribute_not_exists function in DynamoDB Condition Expressions. The
// resulting ConditionBuilder can be used as a part of other Condition
// Expressions or as an argument to the WithCondition() method for the Builder
// struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" exists or not
//     condition := expression.Name("Age").AttributeNotExists()
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Age").AttributeNotExists()
//     "attribute_not_exists (Age))"
func (nb NameBuilder) AttributeNotExists() ConditionBuilder {
	return AttributeNotExists(nb)
}

// AttributeType returns a ConditionBuilder representing the result of the
// attribute_type function in DynamoDB Condition Expressions. The DynamoDB types
// are represented by the type DynamoDBAttributeType. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" has the DynamoDB type Number or not
//     condition := expression.AttributeType(expression.Name("Age"), expression.Number)
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.AttributeType(expression.Name("Age"), expression.Number)
//     // Let :type be an ExpressionAttributeValue representing the value "N"
//     "attribute_type (Age, :type)"
func AttributeType(nameBuilder NameBuilder, attributeType DynamoDBAttributeType) ConditionBuilder {
	v := ValueBuilder{
		value: string(attributeType),
	}
	return ConditionBuilder{
		operandList: []OperandBuilder{nameBuilder, v},
		mode:        attrTypeCond,
	}
}

// AttributeType returns a ConditionBuilder representing the result of the
// attribute_type function in DynamoDB Condition Expressions. The DynamoDB types
// are represented by the type DynamoDBAttributeType. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "Age" has the DynamoDB type Number or not
//     condition := expression.Name("Age").AttributeType(expression.Number)
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("Age").AttributeType(expression.Number)
//     // Let :type be an ExpressionAttributeValue representing the value "N"
//     "attribute_type (Age, :type)"
func (nb NameBuilder) AttributeType(attributeType DynamoDBAttributeType) ConditionBuilder {
	return AttributeType(nb, attributeType)
}

// BeginsWith returns a ConditionBuilder representing the result of the
// begins_with function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "CodeName" starts with the substring "Ben"
//     condition := expression.BeginsWith(expression.Name("CodeName"), "Ben")
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.BeginsWith(expression.Name("CodeName"), "Ben")
//     // Let :ben be an ExpressionAttributeValue representing the value "Ben"
//     "begins_with (CodeName, :ben)"
func BeginsWith(nameBuilder NameBuilder, prefix string) ConditionBuilder {
	v := ValueBuilder{
		value: prefix,
	}
	return ConditionBuilder{
		operandList: []OperandBuilder{nameBuilder, v},
		mode:        beginsWithCond,
	}
}

// BeginsWith returns a ConditionBuilder representing the result of the
// begins_with function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "CodeName" starts with the substring "Ben"
//     condition := expression.Name("CodeName").BeginsWith("Ben")
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("CodeName").BeginsWith("Ben")
//     // Let :ben be an ExpressionAttributeValue representing the value "Ben"
//     "begins_with (CodeName, :ben)"
func (nb NameBuilder) BeginsWith(prefix string) ConditionBuilder {
	return BeginsWith(nb, prefix)
}

// Contains returns a ConditionBuilder representing the result of the
// contains function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "InviteList" has the value "Ben"
//     condition := expression.Contains(expression.Name("InviteList"), "Ben")
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Contains(expression.Name("InviteList"), "Ben")
//     // Let :ben be an ExpressionAttributeValue representing the value "Ben"
//     "contains (InviteList, :ben)"
func Contains(nameBuilder NameBuilder, substr string) ConditionBuilder {
	v := ValueBuilder{
		value: substr,
	}
	return ConditionBuilder{
		operandList: []OperandBuilder{nameBuilder, v},
		mode:        containsCond,
	}
}

// Contains returns a ConditionBuilder representing the result of the
// contains function in DynamoDB Condition Expressions. The resulting
// ConditionBuilder can be used as a part of other Condition Expressions or as
// an argument to the WithCondition() method for the Builder struct.
//
// Example:
//
//     // condition represents the boolean condition of whether the item
//     // attribute "InviteList" has the value "Ben"
//     condition := expression.Name("InviteList").Contains("Ben")
//
//     // Used in another Condition Expression
//     anotherCondition := expression.Not(condition)
//     // Used to make an Builder
//     builder := expression.NewBuilder().WithCondition(condition)
//
// Expression Equivalent:
//
//     expression.Name("InviteList").Contains("Ben")
//     // Let :ben be an ExpressionAttributeValue representing the value "Ben"
//     "contains (InviteList, :ben)"
func (nb NameBuilder) Contains(substr string) ConditionBuilder {
	return Contains(nb, substr)
}

// buildTree builds a tree structure of exprNodes based on the tree
// structure of the input ConditionBuilder's child ConditionBuilders and
// OperandBuilders. buildTree() satisfies the treeBuilder interface so
// ConditionBuilder can be a part of Builder and Expression struct.
func (cb ConditionBuilder) buildTree() (exprNode, error) {
	childNodes, err := cb.buildChildNodes()
	if err != nil {
		return exprNode{}, err
	}
	ret := exprNode{
		children: childNodes,
	}

	switch cb.mode {
	case equalCond, notEqualCond, lessThanCond, lessThanEqualCond, greaterThanCond, greaterThanEqualCond:
		return compareBuildCondition(cb.mode, ret)
	case andCond, orCond:
		return compoundBuildCondition(cb, ret)
	case notCond:
		return notBuildCondition(ret)
	case betweenCond:
		return betweenBuildCondition(ret)
	case inCond:
		return inBuildCondition(cb, ret)
	case attrExistsCond:
		return attrExistsBuildCondition(ret)
	case attrNotExistsCond:
		return attrNotExistsBuildCondition(ret)
	case attrTypeCond:
		return attrTypeBuildCondition(ret)
	case beginsWithCond:
		return beginsWithBuildCondition(ret)
	case containsCond:
		return containsBuildCondition(ret)
	case unsetCond:
		return exprNode{}, newUnsetParameterError("buildTree", "ConditionBuilder")
	default:
		return exprNode{}, fmt.Errorf("build condition error: unsupported mode: %v", cb.mode)
	}
}

// compareBuildCondition is the function to make exprNodes from Compare
// ConditionBuilders. compareBuildCondition is only called by the
// buildTree method. This function assumes that the argument ConditionBuilder
// has the right format.
func compareBuildCondition(conditionMode conditionMode, node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	switch conditionMode {
	case equalCond:
		node.fmtExpr = "$c = $c"
	case notEqualCond:
		node.fmtExpr = "$c <> $c"
	case lessThanCond:
		node.fmtExpr = "$c < $c"
	case lessThanEqualCond:
		node.fmtExpr = "$c <= $c"
	case greaterThanCond:
		node.fmtExpr = "$c > $c"
	case greaterThanEqualCond:
		node.fmtExpr = "$c >= $c"
	default:
		return exprNode{}, fmt.Errorf("build compare condition error: unsupported mode: %v", conditionMode)
	}

	return node, nil
}

// compoundBuildCondition is the function to make exprNodes from And/Or
// ConditionBuilders. compoundBuildCondition is only called by the
// buildTree method. This function assumes that the argument ConditionBuilder
// has the right format.
func compoundBuildCondition(conditionBuilder ConditionBuilder, node exprNode) (exprNode, error) {
	// create a string with escaped characters to substitute them with proper
	// aliases during runtime
	var mode string
	switch conditionBuilder.mode {
	case andCond:
		mode = " AND "
	case orCond:
		mode = " OR "
	default:
		return exprNode{}, fmt.Errorf("build compound condition error: unsupported mode: %v", conditionBuilder.mode)
	}
	node.fmtExpr = "($c)" + strings.Repeat(mode+"($c)", len(conditionBuilder.conditionList)-1)

	return node, nil
}

// notBuildCondition is the function to make exprNodes from Not
// ConditionBuilders. notBuildCondition is only called by the
// buildTree method. This function assumes that the argument ConditionBuilder
// has the right format.
func notBuildCondition(node exprNode) (exprNode, error) {
	// create a string with escaped characters to substitute them with proper
	// aliases during runtime
	node.fmtExpr = "NOT ($c)"

	return node, nil
}

// betweenBuildCondition is the function to make exprNodes from Between
// ConditionBuilders. BuildCondition is only called by the
// buildTree method. This function assumes that the argument ConditionBuilder
// has the right format.
func betweenBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "$c BETWEEN $c AND $c"

	return node, nil
}

// inBuildCondition is the function to make exprNodes from In
// ConditionBuilders. inBuildCondition is only called by the
// buildTree method. This function assumes that the argument ConditionBuilder
// has the right format.
func inBuildCondition(conditionBuilder ConditionBuilder, node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "$c IN ($c" + strings.Repeat(", $c", len(conditionBuilder.operandList)-2) + ")"

	return node, nil
}

// attrExistsBuildCondition is the function to make exprNodes from
// AttrExistsCond ConditionBuilders. attrExistsBuildCondition is only
// called by the buildTree method. This function assumes that the argument
// ConditionBuilder has the right format.
func attrExistsBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "attribute_exists ($c)"

	return node, nil
}

// attrNotExistsBuildCondition is the function to make exprNodes from
// AttrNotExistsCond ConditionBuilders. attrNotExistsBuildCondition is only
// called by the buildTree method. This function assumes that the argument
// ConditionBuilder has the right format.
func attrNotExistsBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "attribute_not_exists ($c)"

	return node, nil
}

// attrTypeBuildCondition is the function to make exprNodes from AttrTypeCond
// ConditionBuilders. attrTypeBuildCondition is only called by the
// buildTree method. This function assumes that the argument
// ConditionBuilder has the right format.
func attrTypeBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "attribute_type ($c, $c)"

	return node, nil
}

// beginsWithBuildCondition is the function to make exprNodes from
// BeginsWithCond ConditionBuilders. beginsWithBuildCondition is only
// called by the buildTree method. This function assumes that the argument
// ConditionBuilder has the right format.
func beginsWithBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "begins_with ($c, $c)"

	return node, nil
}

// containsBuildCondition is the function to make exprNodes from
// ContainsCond ConditionBuilders. containsBuildCondition is only
// called by the buildTree method. This function assumes that the argument
// ConditionBuilder has the right format.
func containsBuildCondition(node exprNode) (exprNode, error) {
	// Create a string with special characters that can be substituted later: $c
	node.fmtExpr = "contains ($c, $c)"

	return node, nil
}

// buildChildNodes creates the list of the child exprNodes. This avoids
// duplication of code amongst the various buildTree functions.
func (cb ConditionBuilder) buildChildNodes() ([]exprNode, error) {
	childNodes := make([]exprNode, 0, len(cb.conditionList)+len(cb.operandList))
	for _, condition := range cb.conditionList {
		node, err := condition.buildTree()
		if err != nil {
			return []exprNode{}, err
		}
		childNodes = append(childNodes, node)
	}
	for _, ope := range cb.operandList {
		operand, err := ope.BuildOperand()
		if err != nil {
			return []exprNode{}, err
		}
		childNodes = append(childNodes, operand.exprNode)
	}

	return childNodes, nil
}