Expression attribute names in DynamoDB - Step-by-Step Execution

Concept Flow - Expression attribute names

Start Query

↓

Check for reserved words or special chars

Yes↓

Define Expression Attribute Names

↓

Use placeholders in query

↓

Execute query with placeholders

↓

Return results

↓

End

When a query uses reserved words or special characters, placeholders called expression attribute names are defined and used in the query to avoid errors.

Execution Sample

DynamoDB

ExpressionAttributeNames = {"#N": "Name"}
FilterExpression = "#N = :val"
Query(..., ExpressionAttributeNames=ExpressionAttributeNames, FilterExpression=FilterExpression)

This query uses an expression attribute name placeholder #N for the reserved word 'Name' to filter items.

Execution Table

Step	Action	ExpressionAttributeNames	FilterExpression	Result
1	Start query preparation	{}		No placeholders yet
2	Detect reserved word 'Name'	{}		Reserved word found
3	Define placeholder #N for 'Name'	{"#N": "Name"}		Placeholder defined
4	Write filter expression using #N	{"#N": "Name"}	#N = :val	Filter expression ready
5	Execute query with placeholders	{"#N": "Name"}	#N = :val	Query runs without error
6	Return filtered results	{"#N": "Name"}	#N = :val	Results returned matching filter

💡 Query completes successfully using expression attribute names to avoid reserved word conflict

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
ExpressionAttributeNames	{}	{"#N": "Name"}	{"#N": "Name"}	{"#N": "Name"}
FilterExpression	""	""	"#N = :val"	"#N = :val"

Key Moments - 2 Insights

Why do we need to use expression attribute names like #N instead of directly using 'Name'?

Because 'Name' is a reserved word in DynamoDB, using it directly in expressions causes errors. Expression attribute names like #N act as placeholders to safely reference reserved words, as shown in execution_table step 3 and 4.

What happens if we forget to define the expression attribute name but use the placeholder in the filter expression?

The query will fail because the placeholder #N is undefined. The execution_table shows that defining ExpressionAttributeNames before using the placeholder is necessary (step 3 before step 4).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what does ExpressionAttributeNames contain?

A {}

B {"#N": "Name"}

C {"Name": "#N"}

D {"#Name": "N"}

💡 Hint

Check the ExpressionAttributeNames column at step 3 in the execution_table

At which step does the filter expression get updated to use the placeholder?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the FilterExpression column in the execution_table to see when it changes from empty to '#N = :val'

If we remove the ExpressionAttributeNames definition, what will happen when executing the query?

A Query fails due to undefined placeholder

B Query ignores the filter expression

C Query runs successfully without placeholders

D Query returns all items without filtering

💡 Hint

Refer to key_moments explanation about missing placeholder definition causing failure

Concept Snapshot

Expression attribute names let you use placeholders (like #N) for reserved words or special characters in DynamoDB queries.
Define them in ExpressionAttributeNames mapping.
Use placeholders in expressions instead of reserved words.
This avoids syntax errors and lets queries run smoothly.
Always match placeholders with definitions.

Full Transcript

Expression attribute names in DynamoDB are placeholders used to avoid conflicts with reserved words or special characters in queries. When a query uses a reserved word like 'Name', you define a placeholder such as #N in ExpressionAttributeNames mapping. Then, you use #N in your filter or update expressions instead of 'Name'. This prevents errors and allows the query to run successfully. The execution flow starts by detecting reserved words, defining placeholders, writing expressions with placeholders, executing the query, and finally returning results. Variables like ExpressionAttributeNames and FilterExpression change step-by-step to prepare the query. Beginners often get confused why placeholders are needed or what happens if they are missing. The visual quiz tests understanding of when and why placeholders are defined and used.

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