Expression attribute names in DynamoDB - Mini Project: Build & Apply

Using Expression Attribute Names in DynamoDB Queries

📖 Scenario: You are managing a DynamoDB table that stores information about books in a library. Some attribute names in the table are reserved words in DynamoDB, so you need to use expression attribute names to query the table safely.

🎯 Goal: Build a DynamoDB query that uses expression attribute names to safely access reserved attribute names in the table.

📋 What You'll Learn

Create a dictionary called expression_attribute_names with the correct mapping for reserved attribute names

Create a string called key_condition_expression using placeholders for attribute names

Write a query dictionary called query_params that includes the table name, key condition expression, and expression attribute names

Complete the query dictionary by adding the ExpressionAttributeNames key with the correct variable

💡 Why This Matters

🌍 Real World

In real-world DynamoDB usage, reserved words can cause errors if used directly in expressions. Expression attribute names let you safely reference these attributes.

💼 Career

Understanding expression attribute names is essential for developers working with DynamoDB to write safe and effective queries and updates.

1

Create the expression attribute names dictionary

Create a dictionary called expression_attribute_names that maps '#yr' to 'year' and '#nm' to 'name'.

DynamoDB

# Create the expression_attribute_names dictionary
# Your code here

Hint

Use a dictionary with keys starting with '#' to map to the actual attribute names.

2

Create the key condition expression string

Create a string variable called key_condition_expression with the value '#yr = :year_val' to use in the query.

DynamoDB

expression_attribute_names = {'#yr': 'year', '#nm': 'name'}
# Create the key_condition_expression string
# Your code here

Hint

Use the placeholder #yr in the string to refer to the reserved attribute year.

3

Create the query parameters dictionary

Create a dictionary called query_params with keys TableName, KeyConditionExpression, and ExpressionAttributeValues. Set TableName to 'Books', KeyConditionExpression to the variable key_condition_expression, and ExpressionAttributeValues to {':year_val': 2020}.

DynamoDB

expression_attribute_names = {'#yr': 'year', '#nm': 'name'}
key_condition_expression = '#yr = :year_val'
# Create the query_params dictionary
# Your code here

Hint

Use the variable key_condition_expression for the key condition expression value.

4

Add ExpressionAttributeNames to the query parameters

Add the key 'ExpressionAttributeNames' to the query_params dictionary and set its value to the variable expression_attribute_names.

DynamoDB

expression_attribute_names = {'#yr': 'year', '#nm': 'name'}
key_condition_expression = '#yr = :year_val'
query_params = {
    'TableName': 'Books',
    'KeyConditionExpression': key_condition_expression,
    'ExpressionAttributeValues': {':year_val': 2020}
}
# Add ExpressionAttributeNames to query_params
# Your code here

Hint

Set the ExpressionAttributeNames key in query_params to the variable expression_attribute_names.

Practice

1. What is the main purpose of using Expression Attribute Names in DynamoDB queries?

easy

A. To increase read capacity units

B. To encrypt data before storing in DynamoDB

C. To create indexes on tables automatically

D. To safely use reserved words or special characters in attribute names

Solution

1. Step 1: Understand reserved words in DynamoDB

   DynamoDB has reserved words that cannot be used directly as attribute names in expressions.

2. Step 2: Role of Expression Attribute Names

   Expression Attribute Names let you replace reserved words or special characters with placeholders starting with # to avoid syntax errors.

3. Final Answer:

   To safely use reserved words or special characters in attribute names -> Option D

4. Quick Check:

   Expression Attribute Names = safe reserved word usage [OK]

Hint: Use #name to replace reserved words in expressions [OK]

Common Mistakes:

• Thinking they encrypt data
• Confusing with indexes
• Using them to increase capacity

2. Which of the following is the correct way to use an expression attribute name for the reserved word status in a DynamoDB UpdateExpression?

easy

A. UpdateExpression: SET #st = :val with ExpressionAttributeNames: {"#st": "status"}

B. UpdateExpression: SET status = :val

C. UpdateExpression: SET :st = :val

D. UpdateExpression: SET status# = :val

Solution

1. Step 1: Identify correct syntax for Expression Attribute Names

   Expression Attribute Names start with # and map to real attribute names in ExpressionAttributeNames dictionary.

2. Step 2: Match syntax with reserved word usage

   UpdateExpression: SET #st = :val with ExpressionAttributeNames: {"#st": "status"} correctly uses #st as placeholder for "status" and defines it in ExpressionAttributeNames.

3. Final Answer:

   UpdateExpression: SET #st = :val with ExpressionAttributeNames: {"#st": "status"} -> Option A

4. Quick Check:

   #placeholder = real name syntax [OK]

Hint: Always prefix attribute names with # in expressions [OK]

Common Mistakes:

• Using reserved word directly without #
• Using : instead of # for attribute names
• Appending # after attribute name

3. Given the following DynamoDB query snippet:

FilterExpression: "#yr = :yearVal"
ExpressionAttributeNames: {"#yr": "year"}
ExpressionAttributeValues: {":yearVal": 2023}

What will this filter expression do?

medium

A. Filter items where attribute 'year' equals 2023

B. Filter items where attribute '#yr' equals 2023

C. Cause a syntax error due to missing # in ExpressionAttributeValues

D. Filter items where attribute 'yearVal' equals 2023

Solution

1. Step 1: Understand ExpressionAttributeNames mapping

   #yr is a placeholder for the attribute name "year" to avoid reserved word conflicts.

2. Step 2: Understand FilterExpression logic

   The filter checks if the attribute "year" equals the value 2023 provided by :yearVal.

3. Final Answer:

   Filter items where attribute 'year' equals 2023 -> Option A

4. Quick Check:

   #yr = year, :yearVal = 2023 [OK]

Hint: Match #name to real attribute, :value to actual value [OK]

Common Mistakes:

• Confusing placeholders with actual attribute names
• Thinking #yr is literal attribute
• Mixing ExpressionAttributeNames and Values

4. You wrote this DynamoDB update:

UpdateExpression: "SET #nm = :nameVal"
ExpressionAttributeNames: {"#name": "name"}
ExpressionAttributeValues: {":nameVal": "Alice"}

Why does this cause an error?

medium

A. ExpressionAttributeValues key ':nameVal' is invalid

B. ExpressionAttributeNames key '#name' does not match placeholder '#nm' in UpdateExpression

C. UpdateExpression cannot use SET with placeholders

D. Missing reserved word declaration

Solution

1. Step 1: Compare placeholders in UpdateExpression and ExpressionAttributeNames

   UpdateExpression uses #nm but ExpressionAttributeNames defines #name, causing mismatch.

2. Step 2: Understand placeholder mapping requirement

   Placeholders must match exactly between expression and attribute names dictionary.

3. Final Answer:

   ExpressionAttributeNames key '#name' does not match placeholder '#nm' in UpdateExpression -> Option B

4. Quick Check:

   Placeholder names must match exactly [OK]

Hint: Match #placeholder names exactly in all places [OK]

Common Mistakes:

• Mismatching placeholder names
• Assuming :value keys cause error
• Thinking SET can't use placeholders

5. You want to update the attribute named order (a reserved word) and the attribute order#count (which contains a special character) in a DynamoDB item. Which is the correct way to write the UpdateExpression and ExpressionAttributeNames?

hard

A. UpdateExpression: "SET #ord = :val1, #ord#count = :val2" with ExpressionAttributeNames: {"#ord": "order", "#ord#count": "order#count"}

B. UpdateExpression: "SET order = :val1, order#count = :val2" with no ExpressionAttributeNames

C. UpdateExpression: "SET #o = :val1, #c = :val2" with ExpressionAttributeNames: {"#o": "order", "#c": "order#count"}

D. UpdateExpression: "SET #order = :val1, #order#count = :val2" with ExpressionAttributeNames: {"#order": "order", "#order#count": "order#count"}

Solution

1. Step 1: Understand reserved words and special characters handling

   Reserved words and special characters must be replaced with placeholders starting with # in expressions.

2. Step 2: Check placeholder naming rules

   Placeholders cannot contain special characters like #, so #order#count is invalid. Use simple placeholders like #o and #c.

3. Step 3: Verify ExpressionAttributeNames mapping

   UpdateExpression: "SET #o = :val1, #c = :val2" with ExpressionAttributeNames: {"#o": "order", "#c": "order#count"} correctly maps #o to "order" and #c to "order#count" with valid placeholder names.

4. Final Answer:

   UpdateExpression: "SET #o = :val1, #c = :val2" with ExpressionAttributeNames: {"#o": "order", "#c": "order#count"} -> Option C

5. Quick Check:

   Use simple # placeholders, map special names correctly [OK]

Hint: Use simple # placeholders; avoid special chars in placeholder names [OK]

Common Mistakes:

• Using special characters in placeholder names
• Not using ExpressionAttributeNames for reserved words
• Trying to use attribute names directly with special chars