Transaction vs batch comparison in DynamoDB - Hands-On Comparison

Transaction vs Batch Operations in DynamoDB

📖 Scenario: You are managing an online bookstore's inventory using DynamoDB. You need to update multiple book records either as a single atomic transaction or as a batch operation.

🎯 Goal: Build two DynamoDB operations: one using a transaction to update multiple items atomically, and another using a batch write to update multiple items without atomicity.

📋 What You'll Learn

Create a list called books with three book items, each having BookID and Stock attributes.

Create a variable called transaction_items that prepares a transaction update for all books to increase stock by 10.

Create a variable called batch_write_items that prepares a batch write request to update all books to increase stock by 10.

Add a final configuration variable called transaction_params that wraps transaction_items for the DynamoDB transact write API.

💡 Why This Matters

🌍 Real World

Managing inventory updates in an online bookstore where some updates must be atomic and others can be batched for efficiency.

💼 Career

Understanding DynamoDB transactions and batch operations is essential for backend developers working with AWS databases to ensure data consistency and performance.

1

DATA SETUP: Create the initial list of books

Create a list called books with these exact dictionaries: {'BookID': 'B001', 'Stock': 5}, {'BookID': 'B002', 'Stock': 3}, and {'BookID': 'B003', 'Stock': 8}.

DynamoDB

# Create the list called books with three book dictionaries
# Your code here

Hint

Use a Python list with three dictionaries exactly as shown.

2

CONFIGURATION: Prepare transaction update items

Create a variable called transaction_items that is a list of dictionaries. Each dictionary should have a Update key with Key using BookID from each book, UpdateExpression to add 10 to Stock, and TableName set to 'BooksTable'.

DynamoDB

books = [
    {'BookID': 'B001', 'Stock': 5},
    {'BookID': 'B002', 'Stock': 3},
    {'BookID': 'B003', 'Stock': 8}
]
# Create transaction_items list with update dictionaries
# Your code here

Hint

Use a list comprehension to create update dictionaries for each book.

3

CORE LOGIC: Prepare batch write update items

Create a variable called batch_write_items that is a list of dictionaries. Each dictionary should have a PutRequest key with Item containing BookID and Stock increased by 10 from each book.

DynamoDB

books = [
    {'BookID': 'B001', 'Stock': 5},
    {'BookID': 'B002', 'Stock': 3},
    {'BookID': 'B003', 'Stock': 8}
]

transaction_items = [
    {
        'Update': {
            'TableName': 'BooksTable',
            'Key': {'BookID': book['BookID']},
            'UpdateExpression': 'SET Stock = Stock + :inc',
            'ExpressionAttributeValues': {':inc': 10}
        }
    } for book in books
]

# Create batch_write_items list with PutRequest dictionaries
# Your code here

Hint

Use a list comprehension to create PutRequest dictionaries for each book with updated stock.

4

COMPLETION: Wrap transaction items in parameters

Create a variable called transaction_params that is a dictionary with key TransactItems set to the transaction_items list.

DynamoDB

books = [
    {'BookID': 'B001', 'Stock': 5},
    {'BookID': 'B002', 'Stock': 3},
    {'BookID': 'B003', 'Stock': 8}
]

transaction_items = [
    {
        'Update': {
            'TableName': 'BooksTable',
            'Key': {'BookID': book['BookID']},
            'UpdateExpression': 'SET Stock = Stock + :inc',
            'ExpressionAttributeValues': {':inc': 10}
        }
    } for book in books
]

batch_write_items = [
    {
        'PutRequest': {
            'Item': {
                'BookID': book['BookID'],
                'Stock': book['Stock'] + 10
            }
        }
    } for book in books
]

# Create transaction_params dictionary with TransactItems key
# Your code here

Hint

Wrap the transaction_items list inside a dictionary with key 'TransactItems'.

Practice

1. Which statement best describes the main difference between a DynamoDB transaction and a batch operation?

easy

A. Transactions are faster than batches for processing many items.

B. Batches guarantee all-or-nothing changes, while transactions do not.

C. Batches can only process one item at a time, transactions can process many.

D. Transactions ensure all-or-nothing changes, while batches do not guarantee atomicity.

Solution

1. Step 1: Understand transaction guarantees

   Transactions in DynamoDB ensure that all operations succeed or none do, providing atomicity.

2. Step 2: Understand batch operation behavior

   Batches process multiple items quickly but do not guarantee that all succeed together; partial success is possible.

3. Final Answer:

   Transactions ensure all-or-nothing changes, while batches do not guarantee atomicity. -> Option D

4. Quick Check:

   Atomicity = Transactions [OK]

Hint: Remember: transactions = all-or-nothing, batches = speed without atomicity [OK]

Common Mistakes:

• Confusing batch operations as atomic
• Assuming transactions are slower always
• Thinking batches process only one item

2. Which of the following is the correct syntax to start a transaction write request in DynamoDB using the AWS SDK?

easy

A. dynamodb.transactGetItems(params, callback);

B. dynamodb.transactWriteItems(params, callback);

C. dynamodb.putItem(params, callback);

D. dynamodb.batchWriteItems(params, callback);

Solution

1. Step 1: Identify transaction write method

   The correct method for transaction writes is transactWriteItems.

2. Step 2: Differentiate from batch and get methods

   batchWriteItems is for batch writes, putItem is for single writes, transactGetItems is for transaction reads.

3. Final Answer:

   dynamodb.transactWriteItems(params, callback); -> Option B

4. Quick Check:

   Transaction write = transactWriteItems [OK]

Hint: Transaction writes use transactWriteItems method [OK]

Common Mistakes:

• Using batchWriteItems for transactions
• Confusing transactGetItems with write operations
• Using putItem for multiple item writes

3. Consider this DynamoDB batch write request that tries to write 3 items. If one item fails due to a conditional check, what will be the result?

medium

A. Only the items that pass the condition are written; others are skipped.

B. All 3 items are written successfully or none are written.

C. The entire batch write fails and no items are written.

D. The batch write retries automatically until all succeed.

Solution

1. Step 1: Understand batch write behavior on failure

   Batch writes do not guarantee atomicity; if one item fails, others can still succeed.

2. Step 2: Check retry and failure handling

   Batch writes return unprocessed items for retry but do not automatically retry all items until success.

3. Final Answer:

   Only the items that pass the condition are written; others are skipped. -> Option A

4. Quick Check:

   Batch partial success = true [OK]

Hint: Batch writes can partially succeed; transactions cannot [OK]

Common Mistakes:

• Assuming batch writes are atomic
• Thinking batch writes auto-retry all failures
• Believing batch writes fail completely on one error

4. You wrote this DynamoDB transaction code but it sometimes partially updates items instead of all or none. What is the likely mistake?

medium

A. Using batchWriteItems instead of transactWriteItems for atomic updates.

B. Not specifying the primary key in the transaction items.

C. Using transactGetItems instead of transactWriteItems.

D. Forgetting to set ReturnConsumedCapacity to TOTAL.

Solution

1. Step 1: Identify the cause of partial updates

   Partial updates happen if batchWriteItems is used, which is not atomic.

2. Step 2: Confirm correct method for atomic transactions

   transactWriteItems ensures all-or-nothing updates, preventing partial writes.

3. Final Answer:

   Using batchWriteItems instead of transactWriteItems for atomic updates. -> Option A

4. Quick Check:

   Atomic update requires transactWriteItems [OK]

Hint: Use transactWriteItems for atomic multi-item updates [OK]

Common Mistakes:

• Mixing batchWriteItems with transaction logic
• Ignoring primary key requirements
• Confusing read and write transaction methods

5. You need to update 10 related items in DynamoDB and ensure either all updates succeed or none do, but also want to minimize latency. Which approach is best?

hard

A. Update items one by one with putItem calls to control errors manually.

B. Use batchWriteItems to update all 10 items quickly without atomicity.

C. Use a single transactWriteItems call with all 10 updates for atomicity.

D. Use transactGetItems to read then batchWriteItems to update.

Solution

1. Step 1: Identify requirement for atomic updates

   All-or-nothing update means transaction is needed for consistency.

2. Step 2: Consider latency and operation limits

   transactWriteItems supports up to 25 items and is optimized for atomic multi-item writes, balancing latency and consistency.

3. Final Answer:

   Use a single transactWriteItems call with all 10 updates for atomicity. -> Option C

4. Quick Check:

   Atomic multi-item update = transactWriteItems [OK]

Hint: Atomic multi-item update? Use transactWriteItems [OK]

Common Mistakes:

• Choosing batchWriteItems despite atomicity need
• Updating items individually causing inconsistency
• Using transactGetItems for writes