Update nested map dynamodb

Question

I have a dynamodb table with an attribute containing a nested map and I would like to update a specific inventory item that is filtered via a filter expression that results in a single item from this map.

How to write an update expression to update the location to "in place three" of the item with name=opel,tags include "x1" (and possibly also f3)? This should just update the first list elements location attribute.

  {
    "inventory": [
    {
      "location": "in place one",      # I want to update this
      "name": "opel",
      "tags": [
        "x1",
        "f3"
      ]
    },
    {
      "location": "in place two",
      "name": "abc",
      "tags": [
        "a3",
        "f5"
      ]
    }],
    "User" :"test" 
  } 

Answer 1

Updated Answer - based on updated question statement

You can update attributes in a nested map using update expressions such that only a part of the item would get updated (ie. DynamoDB would apply the equivalent of a patch to your item) but, because DynamoDB is a document database, all operations (Put, Get, Update, Delete etc.) work on the item as a whole.

So, in your example, assuming User is the partition key and that there is no sort key (I didn't see any attribute that could be a sort key in that example), an Update request might look like this:

table.update_item(
  Key={
    'User': 'test'
  },
  UpdateExpression="SET #inv[0].#loc = :locVal",
  ExpressionAttributeNames={
    '#inv': 'inventory',
    '#loc': 'location'
  },
  ExpressionAttributeValues={
    ':locVal': 'in place three',
  },
)

That said, you do have to know what the item schema looks like and which attributes within the item should be updated exactly.

DynamoDB does NOT have a way to operate on sub-items. Meaning, there is no way to tell Dynamo to execute an operation such as "update item, set 'location' property of elements of the 'inventory' array that have a property of 'name' equal to 'opel'"

This is probably not the answer you were hoping for, but it is what's available today. You may be able to get closer to what you want by changing the schema a bit.

If you need to reference the sub-items by name, perhaps storing something like:

{
  "inventory": {
    "opel": {
       "location": "in place one",      # I want to update this
       "tags": [ "x1", "f3" ]
    },
    "abc": {
       "location": "in place two",
       "tags": [ "a3", "f5" ]
    }
  },
  "User" :"test" 
} 

Then your query would be:

table.update_item(
  Key={
    'User': 'test'
  },
  UpdateExpression="SET #inv.#brand.#loc = :locVal",
  ExpressionAttributeNames={
    '#inv': 'inventory',
    '#loc': 'location',
    '#brand': 'opel'
  },
  ExpressionAttributeValues={
    ':locVal': 'in place three',
  },
)

But YMMV as even this has limitations because you are limited to identifying inventory items by name (ie. you still can't say "update inventory with tag 'x1'"

Ultimately you should carefully consider why you need Dynamo to perform these complex operations for you as opposed to you being specific about what you want to update.

Answer 2

You can update the nested map as follow:

1. First create and empty item attribute of type map. In the example graph is the empty item attribute.

   dynamoTable = dynamodb.Table('abc')
   dynamoTable.put_item(
       Item={
           'email': email_add,
           'graph': {},
       }
   

2. Update nested map as follow:

   brand_name = 'opel'
   DynamoTable = dynamodb.Table('abc')
   
   dynamoTable.update_item(
       Key={
           'email': email_add,
       },
       UpdateExpression="set #Graph.#brand= :name, ",
       ExpressionAttributeNames={
           '#Graph': 'inventory',
           '#brand': str(brand_name),
       },
       ExpressionAttributeValues = {
           ':name': {
               "location": "in place two",
               'tag': {
                   'graph_type':'a3',
                   'graph_title': 'f5'
               } 
           }
   

Answer 3

Updating Mike's answer because that way doesn't work any more (at least for me).

It is working like this now (attention for UpdateExpression and ExpressionAttributeNames):

table.update_item(
  Key={
    'User': 'test'
  },
  UpdateExpression="SET inv.#brand.loc = :locVal",
  ExpressionAttributeNames={
    '#brand': 'opel'
  },
  ExpressionAttributeValues={
    ':locVal': 'in place three',
  },
)

And whatever goes in Key={}, it is always partition key (and sort key, if any).

EDIT: Seems like this way only works when with 2 level nested properties. In this case you would only use "ExpressionAttributeNames" for the "middle" property (in this example, that would be #brand: inv.#brand.loc). I'm not yet sure what is the real rule now.

Answer 4

DynamoDB UpdateExpression does not search on the database for matching cases like SQL (where you can update all items that match some condition). To update an item you first need to identify it and get primary key or composite key, if there are many items that match your criteria, you need to update one by one.

then the issue to update nested objects is to define UpdateExpression,ExpressionAttributeValues & ExpressionAttributeNames to pass to Dynamo Update Api .

I use a recursive function to update nested Objects on dynamoDB. You ask for Python but I use javascript, I think is easy to see this code and implents on Python: https://gist.github.com/crsepulv/4b4a44ccbd165b0abc2b91f76117baa5

/**
 * Recursive function to get UpdateExpression,ExpressionAttributeValues & ExpressionAttributeNames to update a nested object on dynamoDB
 * All levels of the nested object must exist previously on dynamoDB, this only update the value, does not create the branch.
 * Only works with objects of objects, not tested with Arrays.
 * @param obj , the object to update.
 * @param k , the seed is any value, takes sense on the last iteration.
 */
function getDynamoExpression(obj, k) {

    const key = Object.keys(obj);

    let UpdateExpression = 'SET ';
    let ExpressionAttributeValues = {};
    let ExpressionAttributeNames = {};
    let response = {
        UpdateExpression: ' ',
        ExpressionAttributeNames: {},
        ExpressionAttributeValues: {}
    };

    //https://stackoverflow.com/a/16608074/1210463

    /**
     * true when input is object, this means on all levels except the last one.
     */
    if (((!!obj) && (obj.constructor === Object))) {

        response = getDynamoExpression(obj[key[0]], key);
        UpdateExpression = 'SET #' + key + '.' + response['UpdateExpression'].substring(4); //substring deletes 'SET ' for the mid level values.
        ExpressionAttributeNames = {['#' + key]: key[0], ...response['ExpressionAttributeNames']};
        ExpressionAttributeValues = response['ExpressionAttributeValues'];

    } else {
        UpdateExpression = 'SET   = :' + k;
        ExpressionAttributeValues = {
            [':' + k]: obj
        }
    }

    //removes trailing dot on the last level
    if (UpdateExpression.indexOf(". ")) {
        UpdateExpression = UpdateExpression.replace(". ", "");
    }

    return {UpdateExpression, ExpressionAttributeValues, ExpressionAttributeNames};
}

//you can try many levels.
const obj = {
    level1: {
        level2: {
            level3: {
                level4: 'value'
            }
        }
    }
}

Answer 5

I had the same need. Hope this code helps. You only need to invoke compose_update_expression_attr_name_values passing the dictionary containing the new values.

def compose_update_expression_attr_name_values(data: dict) -> (str, dict, dict):
    """ Constructs UpdateExpression, ExpressionAttributeNames, and ExpressionAttributeValues for updating an entry of a DynamoDB table.

    :param data: the dictionary of attribute_values to be updated
    :return: a tuple (UpdateExpression: str, ExpressionAttributeNames: dict(str: str), ExpressionAttributeValues: dict(str: str))
    """
    # prepare recursion input
    expression_list = []
    value_map = {}
    name_map = {}

    # navigate the dict and fill expressions and dictionaries
    _rec_update_expression_attr_name_values(data, "", expression_list, name_map, value_map)

    # compose update expression from single paths
    expression = "SET " + ", ".join(expression_list)

    return expression, name_map, value_map


def _rec_update_expression_attr_name_values(data: dict, path: str, expressions: list, attribute_names: dict,
                                        attribute_values: dict):
    """ Recursively navigates the input and inject contents into expressions, names, and attribute_values.

    :param data: the data dictionary with updated data
    :param path: the navigation path in the original data dictionary to this recursive call
    :param expressions: the list of update expressions constructed so far
    :param attribute_names: a map associating "expression attribute name identifiers" to their actual names in ``data``
    :param attribute_values: a map associating "expression attribute value identifiers" to their actual values in ``data``
    :return: None, since ``expressions``, ``attribute_names``, and ``attribute_values`` get updated during the recursion
    """
    for k in data.keys():
        # generate non-ambiguous identifiers
        rdm = random.randrange(0, 1000)
        attr_name = f"#k_{rdm}_{k}"
        while attr_name in attribute_names.keys():
        rdm = random.randrange(0, 1000)
        attr_name = f"#k_{rdm}_{k}"

        attribute_names[attr_name] = k
        _path = f"{path}.{attr_name}"

        # recursion
        if isinstance(data[k], dict):
            # recursive case
            _rec_update_expression_attr_name_values(data[k], _path, expressions, attribute_names, attribute_values)

        else:
            # base case
            attr_val = f":v_{rdm}_{k}"
            attribute_values[attr_val] = data[k]
            expression = f"{_path} = {attr_val}"
            # remove the initial "."
            expressions.append(expression[1:])