4
0
Fork 0
mirror of https://github.com/rocky-linux/peridot.git synced 2024-12-28 13:00:57 +00:00
peridot/vendor/github.com/aws/aws-sdk-go/service/dynamodb/expression/condition.go

1578 lines
62 KiB
Go
Raw Normal View History

2022-07-07 20:11:50 +00:00
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
}