TransactWriteItems in DynamoDB - Mini Project: Build & Apply

Using TransactWriteItems in DynamoDB

📖 Scenario: You are managing an online bookstore's inventory and orders using DynamoDB. You want to update the stock quantity of a book and create a new order record at the same time, ensuring both actions succeed or fail together.

🎯 Goal: Build a DynamoDB transaction using TransactWriteItems to update the stock of a book and add a new order atomically.

📋 What You'll Learn

Create a transaction request with exactly two actions: one to update the book stock, one to put a new order item.

Use the TransactWriteItems API structure with Update and Put operations.

Specify the table names Books for the stock update and Orders for the new order.

Use the exact attribute names and values as given for the update and put operations.

💡 Why This Matters

🌍 Real World

In real online stores, updating inventory and creating orders must happen together to avoid selling out-of-stock items.

💼 Career

Understanding DynamoDB transactions is important for backend developers working with AWS to ensure data consistency.

1

Create the initial transaction structure

Create a variable called transaction and assign it a dictionary with a key TransactItems set to an empty list.

DynamoDB

transaction = {
    "TransactItems": []
}
# Your code here

Hint

Start by creating a dictionary named transaction with the key TransactItems as an empty list.

2

Add the update operation for book stock

Add a dictionary to transaction["TransactItems"] representing an Update operation on the Books table. The update should set the attribute Stock to 5 for the item with BookId equal to "B123".

DynamoDB

transaction = {
    "TransactItems": [
        # Add Update operation here
    ]
}
# Your code here

Hint

Add an Update dictionary inside TransactItems with the specified table, key, and update expression.

3

Add the put operation for a new order

Append a dictionary to transaction["TransactItems"] representing a Put operation on the Orders table. The item should have OrderId as "O456", BookId as "B123", and Quantity as 1.

DynamoDB

transaction = {
    "TransactItems": [
        {
            "Update": {
                "TableName": "Books",
                "Key": {"BookId": {"S": "B123"}},
                "UpdateExpression": "SET Stock = :newstock",
                "ExpressionAttributeValues": {":newstock": {"N": "5"}}
            }
        },
        # Add Put operation here
    ]
}
# Your code here

Hint

Append a Put dictionary inside TransactItems with the specified table and item attributes.

4

Complete the transaction request

Ensure the transaction dictionary contains exactly two TransactItems: one Update for the Books table and one Put for the Orders table, with the exact keys and values as specified.

DynamoDB

transaction = {
    "TransactItems": [
        {
            "Update": {
                "TableName": "Books",
                "Key": {"BookId": {"S": "B123"}},
                "UpdateExpression": "SET Stock = :newstock",
                "ExpressionAttributeValues": {":newstock": {"N": "5"}}
            }
        },
        {
            "Put": {
                "TableName": "Orders",
                "Item": {
                    "OrderId": {"S": "O456"},
                    "BookId": {"S": "B123"},
                    "Quantity": {"N": "1"}
                }
            }
        }
    ]
}
# Your code here

Hint

Check that your transaction dictionary has both the update and put operations correctly included.

Practice

1. What is the main purpose of TransactWriteItems in DynamoDB?

easy

A. To group multiple write operations into a single atomic transaction

B. To read multiple items from different tables at once

C. To create a backup of the database automatically

D. To perform batch deletes without conditions

Solution

1. Step 1: Understand the role of TransactWriteItems

   TransactWriteItems groups multiple write actions (Put, Update, Delete) into one atomic transaction.

2. Step 2: Compare with other options

   It does not perform reads, backups, or unconditional batch deletes.

3. Final Answer:

   To group multiple write operations into a single atomic transaction -> Option A

4. Quick Check:

   Atomic transaction = group writes together [OK]

Hint: Remember: TransactWriteItems groups writes atomically [OK]

Common Mistakes:

• Confusing TransactWriteItems with batch read operations
• Thinking it automatically backs up data
• Assuming it only deletes items

2. Which of the following is the correct syntax structure for a TransactWriteItems request in DynamoDB?

easy

A. { TransactWriteItems: [{ Get: { TableName: 'MyTable', Key: {...} } }] }

B. { BatchWriteItems: [{ PutRequest: {...} }, { DeleteRequest: {...} }] }

C. { TransactItems: [{ Put: { TableName: 'MyTable', Item: {...} } }, { Update: {...} }] }

D. { WriteItems: [{ Put: {...} }, { Update: {...} }] }

Solution

1. Step 1: Identify correct TransactWriteItems syntax

   The correct syntax uses the key 'TransactItems' with an array of actions like Put and Update.

2. Step 2: Eliminate incorrect options

   BatchWriteItems is a different API; Get is not a write action; WriteItems is not a valid key.

3. Final Answer:

   { TransactItems: [{ Put: { TableName: 'MyTable', Item: {...} } }, { Update: {...} }] } -> Option C

4. Quick Check:

   TransactItems with Put/Update = correct syntax [OK]

Hint: Look for 'TransactItems' key with write actions inside [OK]

Common Mistakes:

• Using BatchWriteItems instead of TransactWriteItems
• Including Get operations inside TransactWriteItems
• Using incorrect key names like WriteItems

3. Given the following TransactWriteItems request, what will happen if the condition in the Update action fails?

{
  TransactItems: [
    { Put: { TableName: 'Users', Item: { UserId: '123', Name: 'Alice' } } },
    { Update: { TableName: 'Users', Key: { UserId: '123' }, UpdateExpression: 'SET Age = :age', ConditionExpression: 'attribute_exists(UserId)', ExpressionAttributeValues: { ':age': 30 } } }
  ]
}

medium

A. Put action succeeds; Update action is skipped

B. Both actions succeed regardless of the condition

C. Update action succeeds; Put action is skipped

D. Both Put and Update actions are rolled back; no changes are applied

Solution

1. Step 1: Understand TransactWriteItems atomicity

   All actions in TransactWriteItems succeed or all fail together as one transaction.

2. Step 2: Analyze condition failure effect

   If the Update's condition fails, the entire transaction rolls back, including the Put.

3. Final Answer:

   Both Put and Update actions are rolled back; no changes are applied -> Option D

4. Quick Check:

   Condition failure rolls back entire transaction [OK]

Hint: If any condition fails, whole TransactWriteItems rolls back [OK]

Common Mistakes:

• Assuming partial success when condition fails
• Thinking Put action always succeeds
• Ignoring atomicity of TransactWriteItems

4. You wrote this TransactWriteItems request but it fails with a syntax error:

{
  TransactItems: [
    { Put: { TableName: 'Orders', Item: { OrderId: '001', Status: 'Pending' } } },
    { Delete: { TableName: 'Orders', Key: { OrderId: '002' } } }
  ],
  ReturnConsumedCapacity: 'TOTAL'
}

What is the likely cause of the error?

medium

A. Delete action requires a ConditionExpression

B. Missing comma after the TransactItems array

C. TransactItems must be an object, not an array

D. TableName cannot be specified inside Put or Delete actions

Solution

1. Step 1: Check JSON syntax in the request

   ReturnConsumedCapacity is a valid parameter, but the JSON is invalid due to a missing comma after the closing bracket (]) of the TransactItems array.

2. Step 2: Validate other parts

   Delete and Put actions are correctly structured; TransactItems must be an array; TableName is required inside actions.

3. Final Answer:

   Missing comma after the TransactItems array -> Option B

4. Quick Check:

   JSON requires commas between object properties [OK]

Hint: Validate JSON syntax: add commas between top-level properties [OK]

Common Mistakes:

• Omitting commas in JSON request objects
• Forgetting TableName inside each action
• Misusing array vs object for TransactItems

5. You want to atomically update a user's email and delete a related temporary token in DynamoDB using TransactWriteItems. Which of the following request structures correctly achieves this?

hard

A. { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] }

B. { BatchWriteItems: [ { UpdateRequest: { Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { DeleteRequest: { Key: { TokenId: 't1' } } } ] }

C. { TransactItems: [ { Put: { TableName: 'Users', Item: { UserId: 'u1', Email: '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] }

D. { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ], ReturnValuesOnConditionCheckFailure: 'ALL_OLD' }

Solution

1. Step 1: Identify correct atomic update and delete

   { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } uses TransactWriteItems with Update and Delete actions correctly structured.

2. Step 2: Eliminate incorrect options

   { BatchWriteItems: [ { UpdateRequest: { Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { DeleteRequest: { Key: { TokenId: 't1' } } } ] } uses BatchWriteItems which does not support Update; { TransactItems: [ { Put: { TableName: 'Users', Item: { UserId: 'u1', Email: '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } uses Put which replaces entire item, not update; { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e' } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ], ReturnValuesOnConditionCheckFailure: 'ALL_OLD' } includes unsupported parameter ReturnValuesOnConditionCheckFailure.

3. Final Answer:

   { TransactItems: [ { Update: { TableName: 'Users', Key: { UserId: 'u1' }, UpdateExpression: 'SET Email = :e', ExpressionAttributeValues: { ':e': '[e-mail]' } } }, { Delete: { TableName: 'Tokens', Key: { TokenId: 't1' } } } ] } -> Option A

4. Quick Check:

   Use Update and Delete inside TransactItems for atomic changes [OK]

Hint: Use Update and Delete inside TransactItems for atomic writes [OK]

Common Mistakes:

• Using BatchWriteItems for updates
• Using Put instead of Update to change attributes
• Adding unsupported parameters in TransactWriteItems