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) // expr := builder.Build() // // queryInput := dynamodb.QueryInput{ // KeyConditionExpression: expr.KeyCondition(), // ProjectionExpression: expr.Projection(), // ExpressionAttributeNames: expr.Names(), // ExpressionAttributeValues: expr.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) // expr := builder.Build() // // queryInput := dynamodb.QueryInput{ // KeyConditionExpression: expr.KeyCondition(), // ProjectionExpression: expr.Projection(), // ExpressionAttributeNames: expr.Names(), // ExpressionAttributeValues: expr.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 // expr := 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 // expr := 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 // expr := 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 // expr := 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 // expr := 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) // expr := builder.Build() // // queryInput := dynamodb.QueryInput{ // KeyConditionExpression: expr.KeyCondition(), // ProjectionExpression: expr.Projection(), // ExpressionAttributeNames: expr.Names(), // ExpressionAttributeValues: expr.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 } if s, exists := e.expressionMap[expressionType]; exists { return &s } return nil } // 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 }