mirror of
https://github.com/Luzifer/mondash.git
synced 2024-12-24 21:11:19 +00:00
636 lines
23 KiB
Go
636 lines
23 KiB
Go
|
package expression
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"sort"
|
||
|
|
||
|
"github.com/aws/aws-sdk-go/aws"
|
||
|
"github.com/aws/aws-sdk-go/service/dynamodb"
|
||
|
)
|
||
|
|
||
|
// expressionType specifies the type of Expression. Declaring this type is used
|
||
|
// to eliminate magic strings
|
||
|
type expressionType string
|
||
|
|
||
|
const (
|
||
|
projection expressionType = "projection"
|
||
|
keyCondition = "keyCondition"
|
||
|
condition = "condition"
|
||
|
filter = "filter"
|
||
|
update = "update"
|
||
|
)
|
||
|
|
||
|
// Implement the Sort interface
|
||
|
type typeList []expressionType
|
||
|
|
||
|
func (l typeList) Len() int {
|
||
|
return len(l)
|
||
|
}
|
||
|
|
||
|
func (l typeList) Less(i, j int) bool {
|
||
|
return string(l[i]) < string(l[j])
|
||
|
}
|
||
|
|
||
|
func (l typeList) Swap(i, j int) {
|
||
|
l[i], l[j] = l[j], l[i]
|
||
|
}
|
||
|
|
||
|
// Builder represents the struct that builds the Expression struct. Methods such
|
||
|
// as WithProjection() and WithCondition() can add different kinds of DynamoDB
|
||
|
// Expressions to the Builder. The method Build() creates an Expression struct
|
||
|
// with the specified types of DynamoDB Expressions.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// keyCond := expression.Key("someKey").Equal(expression.Value("someValue"))
|
||
|
// proj := expression.NamesList(expression.Name("aName"), expression.Name("anotherName"), expression.Name("oneOtherName"))
|
||
|
//
|
||
|
// builder := expression.NewBuilder().WithKeyCondition(keyCond).WithProjection(proj)
|
||
|
// expression := builder.Build()
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
type Builder struct {
|
||
|
expressionMap map[expressionType]treeBuilder
|
||
|
}
|
||
|
|
||
|
// NewBuilder returns an empty Builder struct. Methods such as WithProjection()
|
||
|
// and WithCondition() can add different kinds of DynamoDB Expressions to the
|
||
|
// Builder. The method Build() creates an Expression struct with the specified
|
||
|
// types of DynamoDB Expressions.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// keyCond := expression.Key("someKey").Equal(expression.Value("someValue"))
|
||
|
// proj := expression.NamesList(expression.Name("aName"), expression.Name("anotherName"), expression.Name("oneOtherName"))
|
||
|
// builder := expression.NewBuilder().WithKeyCondition(keyCond).WithProjection(proj)
|
||
|
func NewBuilder() Builder {
|
||
|
return Builder{}
|
||
|
}
|
||
|
|
||
|
// Build builds an Expression struct representing multiple types of DynamoDB
|
||
|
// Expressions. Getter methods on the resulting Expression struct returns the
|
||
|
// DynamoDB Expression strings as well as the maps that correspond to
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues. Calling Build() on an
|
||
|
// empty Builder returns the typed error EmptyParameterError.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // keyCond represents the Key Condition Expression
|
||
|
// keyCond := expression.Key("someKey").Equal(expression.Value("someValue"))
|
||
|
// // proj represents the Projection Expression
|
||
|
// proj := expression.NamesList(expression.Name("aName"), expression.Name("anotherName"), expression.Name("oneOtherName"))
|
||
|
//
|
||
|
// // Add keyCond and proj to builder as a Key Condition and Projection
|
||
|
// // respectively
|
||
|
// builder := expression.NewBuilder().WithKeyCondition(keyCond).WithProjection(proj)
|
||
|
// expression := builder.Build()
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (b Builder) Build() (Expression, error) {
|
||
|
if b.expressionMap == nil {
|
||
|
return Expression{}, newUnsetParameterError("Build", "Builder")
|
||
|
}
|
||
|
|
||
|
aliasList, expressionMap, err := b.buildChildTrees()
|
||
|
if err != nil {
|
||
|
return Expression{}, err
|
||
|
}
|
||
|
|
||
|
expression := Expression{
|
||
|
expressionMap: expressionMap,
|
||
|
}
|
||
|
|
||
|
if len(aliasList.namesList) != 0 {
|
||
|
namesMap := map[string]*string{}
|
||
|
for ind, val := range aliasList.namesList {
|
||
|
namesMap[fmt.Sprintf("#%v", ind)] = aws.String(val)
|
||
|
}
|
||
|
expression.namesMap = namesMap
|
||
|
}
|
||
|
|
||
|
if len(aliasList.valuesList) != 0 {
|
||
|
valuesMap := map[string]*dynamodb.AttributeValue{}
|
||
|
for i := 0; i < len(aliasList.valuesList); i++ {
|
||
|
valuesMap[fmt.Sprintf(":%v", i)] = &aliasList.valuesList[i]
|
||
|
}
|
||
|
expression.valuesMap = valuesMap
|
||
|
}
|
||
|
|
||
|
return expression, nil
|
||
|
}
|
||
|
|
||
|
// buildChildTrees compiles the list of treeBuilders that are the children of
|
||
|
// the argument Builder. The returned aliasList represents all the alias tokens
|
||
|
// used in the expression strings. The returned map[string]string maps the type
|
||
|
// of expression (i.e. "condition", "update") to the appropriate expression
|
||
|
// string.
|
||
|
func (b Builder) buildChildTrees() (aliasList, map[expressionType]string, error) {
|
||
|
aList := aliasList{}
|
||
|
formattedExpressions := map[expressionType]string{}
|
||
|
keys := typeList{}
|
||
|
|
||
|
for expressionType := range b.expressionMap {
|
||
|
keys = append(keys, expressionType)
|
||
|
}
|
||
|
|
||
|
sort.Sort(keys)
|
||
|
|
||
|
for _, key := range keys {
|
||
|
node, err := b.expressionMap[key].buildTree()
|
||
|
if err != nil {
|
||
|
return aliasList{}, nil, err
|
||
|
}
|
||
|
formattedExpression, err := node.buildExpressionString(&aList)
|
||
|
if err != nil {
|
||
|
return aliasList{}, nil, err
|
||
|
}
|
||
|
formattedExpressions[key] = formattedExpression
|
||
|
}
|
||
|
|
||
|
return aList, formattedExpressions, nil
|
||
|
}
|
||
|
|
||
|
// WithCondition method adds the argument ConditionBuilder as a Condition
|
||
|
// Expression to the argument Builder. If the argument Builder already has a
|
||
|
// ConditionBuilder representing a Condition Expression, WithCondition()
|
||
|
// overwrites the existing ConditionBuilder.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let builder be an existing Builder{} and cond be an existing
|
||
|
// // ConditionBuilder{}
|
||
|
// builder = builder.WithCondition(cond)
|
||
|
//
|
||
|
// // add other DynamoDB Expressions to the builder. let proj be an already
|
||
|
// // existing ProjectionBuilder
|
||
|
// builder = builder.WithProjection(proj)
|
||
|
// // create an Expression struct
|
||
|
// expression := builder.Build()
|
||
|
func (b Builder) WithCondition(conditionBuilder ConditionBuilder) Builder {
|
||
|
if b.expressionMap == nil {
|
||
|
b.expressionMap = map[expressionType]treeBuilder{}
|
||
|
}
|
||
|
b.expressionMap[condition] = conditionBuilder
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// WithProjection method adds the argument ProjectionBuilder as a Projection
|
||
|
// Expression to the argument Builder. If the argument Builder already has a
|
||
|
// ProjectionBuilder representing a Projection Expression, WithProjection()
|
||
|
// overwrites the existing ProjectionBuilder.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let builder be an existing Builder{} and proj be an existing
|
||
|
// // ProjectionBuilder{}
|
||
|
// builder = builder.WithProjection(proj)
|
||
|
//
|
||
|
// // add other DynamoDB Expressions to the builder. let cond be an already
|
||
|
// // existing ConditionBuilder
|
||
|
// builder = builder.WithCondition(cond)
|
||
|
// // create an Expression struct
|
||
|
// expression := builder.Build()
|
||
|
func (b Builder) WithProjection(projectionBuilder ProjectionBuilder) Builder {
|
||
|
if b.expressionMap == nil {
|
||
|
b.expressionMap = map[expressionType]treeBuilder{}
|
||
|
}
|
||
|
b.expressionMap[projection] = projectionBuilder
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// WithKeyCondition method adds the argument KeyConditionBuilder as a Key
|
||
|
// Condition Expression to the argument Builder. If the argument Builder already
|
||
|
// has a KeyConditionBuilder representing a Key Condition Expression,
|
||
|
// WithKeyCondition() overwrites the existing KeyConditionBuilder.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let builder be an existing Builder{} and keyCond be an existing
|
||
|
// // KeyConditionBuilder{}
|
||
|
// builder = builder.WithKeyCondition(keyCond)
|
||
|
//
|
||
|
// // add other DynamoDB Expressions to the builder. let cond be an already
|
||
|
// // existing ConditionBuilder
|
||
|
// builder = builder.WithCondition(cond)
|
||
|
// // create an Expression struct
|
||
|
// expression := builder.Build()
|
||
|
func (b Builder) WithKeyCondition(keyConditionBuilder KeyConditionBuilder) Builder {
|
||
|
if b.expressionMap == nil {
|
||
|
b.expressionMap = map[expressionType]treeBuilder{}
|
||
|
}
|
||
|
b.expressionMap[keyCondition] = keyConditionBuilder
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// WithFilter method adds the argument ConditionBuilder as a Filter Expression
|
||
|
// to the argument Builder. If the argument Builder already has a
|
||
|
// ConditionBuilder representing a Filter Expression, WithFilter()
|
||
|
// overwrites the existing ConditionBuilder.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let builder be an existing Builder{} and filt be an existing
|
||
|
// // ConditionBuilder{}
|
||
|
// builder = builder.WithFilter(filt)
|
||
|
//
|
||
|
// // add other DynamoDB Expressions to the builder. let cond be an already
|
||
|
// // existing ConditionBuilder
|
||
|
// builder = builder.WithCondition(cond)
|
||
|
// // create an Expression struct
|
||
|
// expression := builder.Build()
|
||
|
func (b Builder) WithFilter(filterBuilder ConditionBuilder) Builder {
|
||
|
if b.expressionMap == nil {
|
||
|
b.expressionMap = map[expressionType]treeBuilder{}
|
||
|
}
|
||
|
b.expressionMap[filter] = filterBuilder
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// WithUpdate method adds the argument UpdateBuilder as an Update Expression
|
||
|
// to the argument Builder. If the argument Builder already has a UpdateBuilder
|
||
|
// representing a Update Expression, WithUpdate() overwrites the existing
|
||
|
// UpdateBuilder.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let builder be an existing Builder{} and update be an existing
|
||
|
// // UpdateBuilder{}
|
||
|
// builder = builder.WithUpdate(update)
|
||
|
//
|
||
|
// // add other DynamoDB Expressions to the builder. let cond be an already
|
||
|
// // existing ConditionBuilder
|
||
|
// builder = builder.WithCondition(cond)
|
||
|
// // create an Expression struct
|
||
|
// expression := builder.Build()
|
||
|
func (b Builder) WithUpdate(updateBuilder UpdateBuilder) Builder {
|
||
|
if b.expressionMap == nil {
|
||
|
b.expressionMap = map[expressionType]treeBuilder{}
|
||
|
}
|
||
|
b.expressionMap[update] = updateBuilder
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
// Expression represents a collection of DynamoDB Expressions. The getter
|
||
|
// methods of the Expression struct retrieves the formatted DynamoDB
|
||
|
// Expressions, ExpressionAttributeNames, and ExpressionAttributeValues.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // keyCond represents the Key Condition Expression
|
||
|
// keyCond := expression.Key("someKey").Equal(expression.Value("someValue"))
|
||
|
// // proj represents the Projection Expression
|
||
|
// proj := expression.NamesList(expression.Name("aName"), expression.Name("anotherName"), expression.Name("oneOtherName"))
|
||
|
//
|
||
|
// // Add keyCond and proj to builder as a Key Condition and Projection
|
||
|
// // respectively
|
||
|
// builder := expression.NewBuilder().WithKeyCondition(keyCond).WithProjection(proj)
|
||
|
// expression := builder.Build()
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
type Expression struct {
|
||
|
expressionMap map[expressionType]string
|
||
|
namesMap map[string]*string
|
||
|
valuesMap map[string]*dynamodb.AttributeValue
|
||
|
}
|
||
|
|
||
|
// treeBuilder interface is fulfilled by builder structs that represent
|
||
|
// different types of Expressions.
|
||
|
type treeBuilder interface {
|
||
|
// buildTree creates the tree structure of exprNodes. The tree structure
|
||
|
// of exprNodes are traversed in order to build the string representing
|
||
|
// different types of Expressions as well as the maps that represent
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues.
|
||
|
buildTree() (exprNode, error)
|
||
|
}
|
||
|
|
||
|
// Condition returns the *string corresponding to the Condition Expression
|
||
|
// of the argument Expression. This method is used to satisfy the members of
|
||
|
// DynamoDB input structs. If the Expression does not have a condition
|
||
|
// expression this method returns nil.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// deleteInput := dynamodb.DeleteItemInput{
|
||
|
// ConditionExpression: expression.Condition(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// Key: map[string]*dynamodb.AttributeValue{
|
||
|
// "PartitionKey": &dynamodb.AttributeValue{
|
||
|
// S: aws.String("SomeKey"),
|
||
|
// },
|
||
|
// },
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Condition() *string {
|
||
|
return e.returnExpression(condition)
|
||
|
}
|
||
|
|
||
|
// Filter returns the *string corresponding to the Filter Expression of the
|
||
|
// argument Expression. This method is used to satisfy the members of DynamoDB
|
||
|
// input structs. If the Expression does not have a filter expression this
|
||
|
// method returns nil.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// FilterExpression: expression.Filter(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Filter() *string {
|
||
|
return e.returnExpression(filter)
|
||
|
}
|
||
|
|
||
|
// Projection returns the *string corresponding to the Projection Expression
|
||
|
// of the argument Expression. This method is used to satisfy the members of
|
||
|
// DynamoDB input structs. If the Expression does not have a projection
|
||
|
// expression this method returns nil.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Projection() *string {
|
||
|
return e.returnExpression(projection)
|
||
|
}
|
||
|
|
||
|
// KeyCondition returns the *string corresponding to the Key Condition
|
||
|
// Expression of the argument Expression. This method is used to satisfy the
|
||
|
// members of DynamoDB input structs. If the argument Expression does not have a
|
||
|
// KeyConditionExpression, KeyCondition() returns nil.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) KeyCondition() *string {
|
||
|
return e.returnExpression(keyCondition)
|
||
|
}
|
||
|
|
||
|
// Update returns the *string corresponding to the Update Expression of the
|
||
|
// argument Expression. This method is used to satisfy the members of DynamoDB
|
||
|
// input structs. If the argument Expression does not have a UpdateExpression,
|
||
|
// Update() returns nil.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// updateInput := dynamodb.UpdateInput{
|
||
|
// Key: map[string]*dynamodb.AttributeValue{
|
||
|
// "PartitionKey": {
|
||
|
// S: aws.String("someKey"),
|
||
|
// },
|
||
|
// },
|
||
|
// UpdateExpression: expression.Update(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Update() *string {
|
||
|
return e.returnExpression(update)
|
||
|
}
|
||
|
|
||
|
// Names returns the map[string]*string corresponding to the
|
||
|
// ExpressionAttributeNames of the argument Expression. This method is used to
|
||
|
// satisfy the members of DynamoDB input structs. If Expression does not use
|
||
|
// ExpressionAttributeNames, this method returns nil. The
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues member of the input
|
||
|
// struct must always be assigned when using the Expression struct since all
|
||
|
// item attribute names and values are aliased. That means that if the
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues member is not assigned
|
||
|
// with the corresponding Names() and Values() methods, the DynamoDB operation
|
||
|
// will run into a logic error.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Names() map[string]*string {
|
||
|
return e.namesMap
|
||
|
}
|
||
|
|
||
|
// Values returns the map[string]*dynamodb.AttributeValue corresponding to
|
||
|
// the ExpressionAttributeValues of the argument Expression. This method is used
|
||
|
// to satisfy the members of DynamoDB input structs. If Expression does not use
|
||
|
// ExpressionAttributeValues, this method returns nil. The
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues member of the input
|
||
|
// struct must always be assigned when using the Expression struct since all
|
||
|
// item attribute names and values are aliased. That means that if the
|
||
|
// ExpressionAttributeNames and ExpressionAttributeValues member is not assigned
|
||
|
// with the corresponding Names() and Values() methods, the DynamoDB operation
|
||
|
// will run into a logic error.
|
||
|
//
|
||
|
// Example:
|
||
|
//
|
||
|
// // let expression be an instance of Expression{}
|
||
|
//
|
||
|
// queryInput := dynamodb.QueryInput{
|
||
|
// KeyConditionExpression: expression.KeyCondition(),
|
||
|
// ProjectionExpression: expression.Projection(),
|
||
|
// ExpressionAttributeNames: expression.Names(),
|
||
|
// ExpressionAttributeValues: expression.Values(),
|
||
|
// TableName: aws.String("SomeTable"),
|
||
|
// }
|
||
|
func (e Expression) Values() map[string]*dynamodb.AttributeValue {
|
||
|
return e.valuesMap
|
||
|
}
|
||
|
|
||
|
// returnExpression returns *string corresponding to the type of Expression
|
||
|
// string specified by the expressionType. If there is no corresponding
|
||
|
// expression available in Expression, the method returns nil
|
||
|
func (e Expression) returnExpression(expressionType expressionType) *string {
|
||
|
if e.expressionMap == nil {
|
||
|
return nil
|
||
|
}
|
||
|
return aws.String(e.expressionMap[expressionType])
|
||
|
}
|
||
|
|
||
|
// exprNode are the generic nodes that represents both Operands and
|
||
|
// Conditions. The purpose of exprNode is to be able to call an generic
|
||
|
// recursive function on the top level exprNode to be able to determine a root
|
||
|
// node in order to deduplicate name aliases.
|
||
|
// fmtExpr is a string that has escaped characters to refer to
|
||
|
// names/values/children which needs to be aliased at runtime in order to avoid
|
||
|
// duplicate values. The rules are as follows:
|
||
|
// $n: Indicates that an alias of a name needs to be inserted. The
|
||
|
// corresponding name to be alias is in the []names slice.
|
||
|
// $v: Indicates that an alias of a value needs to be inserted. The
|
||
|
// corresponding value to be alias is in the []values slice.
|
||
|
// $c: Indicates that the fmtExpr of a child exprNode needs to be inserted.
|
||
|
// The corresponding child node is in the []children slice.
|
||
|
type exprNode struct {
|
||
|
names []string
|
||
|
values []dynamodb.AttributeValue
|
||
|
children []exprNode
|
||
|
fmtExpr string
|
||
|
}
|
||
|
|
||
|
// aliasList keeps track of all the names we need to alias in the nested
|
||
|
// struct of conditions and operands. This allows each alias to be unique.
|
||
|
// aliasList is passed in as a pointer when buildChildTrees is called in
|
||
|
// order to deduplicate all names within the tree strcuture of the exprNodes.
|
||
|
type aliasList struct {
|
||
|
namesList []string
|
||
|
valuesList []dynamodb.AttributeValue
|
||
|
}
|
||
|
|
||
|
// buildExpressionString returns a string with aliasing for names/values
|
||
|
// specified by aliasList. The string corresponds to the expression that the
|
||
|
// exprNode tree represents.
|
||
|
func (en exprNode) buildExpressionString(aliasList *aliasList) (string, error) {
|
||
|
// Since each exprNode contains a slice of names, values, and children that
|
||
|
// correspond to the escaped characters, we an index to traverse the slices
|
||
|
index := struct {
|
||
|
name, value, children int
|
||
|
}{}
|
||
|
|
||
|
formattedExpression := en.fmtExpr
|
||
|
|
||
|
for i := 0; i < len(formattedExpression); {
|
||
|
if formattedExpression[i] != '$' {
|
||
|
i++
|
||
|
continue
|
||
|
}
|
||
|
|
||
|
if i == len(formattedExpression)-1 {
|
||
|
return "", fmt.Errorf("buildexprNode error: invalid escape character")
|
||
|
}
|
||
|
|
||
|
var alias string
|
||
|
var err error
|
||
|
// if an escaped character is found, substitute it with the proper alias
|
||
|
// TODO consider AST instead of string in the future
|
||
|
switch formattedExpression[i+1] {
|
||
|
case 'n':
|
||
|
alias, err = substitutePath(index.name, en, aliasList)
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
index.name++
|
||
|
|
||
|
case 'v':
|
||
|
alias, err = substituteValue(index.value, en, aliasList)
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
index.value++
|
||
|
|
||
|
case 'c':
|
||
|
alias, err = substituteChild(index.children, en, aliasList)
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
index.children++
|
||
|
|
||
|
default:
|
||
|
return "", fmt.Errorf("buildexprNode error: invalid escape rune %#v", formattedExpression[i+1])
|
||
|
}
|
||
|
formattedExpression = formattedExpression[:i] + alias + formattedExpression[i+2:]
|
||
|
i += len(alias)
|
||
|
}
|
||
|
|
||
|
return formattedExpression, nil
|
||
|
}
|
||
|
|
||
|
// substitutePath substitutes the escaped character $n with the appropriate
|
||
|
// alias.
|
||
|
func substitutePath(index int, node exprNode, aliasList *aliasList) (string, error) {
|
||
|
if index >= len(node.names) {
|
||
|
return "", fmt.Errorf("substitutePath error: exprNode []names out of range")
|
||
|
}
|
||
|
str, err := aliasList.aliasPath(node.names[index])
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
return str, nil
|
||
|
}
|
||
|
|
||
|
// substituteValue substitutes the escaped character $v with the appropriate
|
||
|
// alias.
|
||
|
func substituteValue(index int, node exprNode, aliasList *aliasList) (string, error) {
|
||
|
if index >= len(node.values) {
|
||
|
return "", fmt.Errorf("substituteValue error: exprNode []values out of range")
|
||
|
}
|
||
|
str, err := aliasList.aliasValue(node.values[index])
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
return str, nil
|
||
|
}
|
||
|
|
||
|
// substituteChild substitutes the escaped character $c with the appropriate
|
||
|
// alias.
|
||
|
func substituteChild(index int, node exprNode, aliasList *aliasList) (string, error) {
|
||
|
if index >= len(node.children) {
|
||
|
return "", fmt.Errorf("substituteChild error: exprNode []children out of range")
|
||
|
}
|
||
|
return node.children[index].buildExpressionString(aliasList)
|
||
|
}
|
||
|
|
||
|
// aliasValue returns the corresponding alias to the dav value argument. Since
|
||
|
// values are not deduplicated as of now, all values are just appended to the
|
||
|
// aliasList and given the index as the alias.
|
||
|
func (al *aliasList) aliasValue(dav dynamodb.AttributeValue) (string, error) {
|
||
|
al.valuesList = append(al.valuesList, dav)
|
||
|
return fmt.Sprintf(":%d", len(al.valuesList)-1), nil
|
||
|
}
|
||
|
|
||
|
// aliasPath returns the corresponding alias to the argument string. The
|
||
|
// argument is checked against all existing aliasList names in order to avoid
|
||
|
// duplicate strings getting two different aliases.
|
||
|
func (al *aliasList) aliasPath(nm string) (string, error) {
|
||
|
for ind, name := range al.namesList {
|
||
|
if nm == name {
|
||
|
return fmt.Sprintf("#%d", ind), nil
|
||
|
}
|
||
|
}
|
||
|
al.namesList = append(al.namesList, nm)
|
||
|
return fmt.Sprintf("#%d", len(al.namesList)-1), nil
|
||
|
}
|