Transaction error handling in DynamoDB - Step-by-Step Execution

Concept Flow - Transaction error handling

Start Transaction

↓

Execute Operations

↓

Any Operation Fails?

Yes→Abort Transaction

↓

Return Error

↓

Commit Transaction

↓

Return Success

This flow shows how a DynamoDB transaction runs all operations together, aborting and returning an error if any operation fails, or committing if all succeed.

Execution Sample

DynamoDB

TransactWriteItems({
  TransactItems: [
    { Put: { TableName: 'Users', Item: {UserId: '1', Name: 'Alice'} } },
    { Update: { TableName: 'Orders', Key: {OrderId: '100'}, UpdateExpression: 'SET #S = :s', ConditionExpression: 'attribute_exists(OrderId)', ExpressionAttributeNames: {'#S': 'Status'}, ExpressionAttributeValues: {':s': 'Processed'} } }
  ]
})

This transaction tries to put a new user and update an order status together.

Execution Table

Step	Operation	Result	Action Taken	Transaction State
1	Put UserId=1	Success	Proceed to next operation	Pending
2	Update OrderId=100	Fail (Order not found)	Abort transaction	Aborted
3	Commit	Skipped	Return error to caller	Aborted

💡 Transaction aborted because update operation failed (Order not found). No changes committed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
TransactionState	Not started	Pending	Aborted	Aborted
OperationsCompleted	0	1	1	1
Error	None	None	Order not found	Order not found

Key Moments - 2 Insights

Why does the transaction abort even though the first operation succeeded?

Because DynamoDB transactions require all operations to succeed. As shown in execution_table step 2, the update failed, so the whole transaction is aborted to keep data consistent.

What happens to the data from the first operation when the transaction aborts?

No data is saved. The transaction is atomic, so partial changes like the successful put in step 1 are rolled back when the transaction aborts (execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the transaction state after the first operation?

A Pending

B Committed

C Aborted

D Not started

💡 Hint

Check the 'Transaction State' column at step 1 in the execution_table.

At which step does the transaction decide to abort?

A Step 1

B Step 2

C Step 3

D No abort occurs

💡 Hint

Look at the 'Action Taken' column in execution_table for the step where abort happens.

If the update operation succeeded, what would happen at step 3?

A Transaction would abort

B Transaction would retry

C Transaction would commit

D Transaction would skip commit

💡 Hint

Refer to the flow in concept_flow and the 'Commit Transaction' step.

Concept Snapshot

DynamoDB transactions run multiple operations atomically.
If any operation fails, the whole transaction aborts.
No partial changes are saved on failure.
On success, all changes commit together.
Use TransactWriteItems or TransactGetItems APIs.
Handle errors to retry or report failure.

Full Transcript

In DynamoDB transaction error handling, all operations in a transaction must succeed for the transaction to commit. If any operation fails, the transaction aborts and no changes are saved. For example, if a put operation succeeds but a subsequent update fails, the entire transaction is rolled back. This ensures data consistency. The execution table shows each step: the first operation succeeds, the second fails, causing an abort and skipping commit. Variables track the transaction state changing from pending to aborted. Beginners often wonder why a successful operation is undone; this is because transactions are atomic. Another common question is what happens to data on abort; the answer is no partial data is saved. The visual quiz tests understanding of transaction state changes and abort points. Remember, always handle transaction errors to maintain reliable applications.

Practice

1. What is the main purpose of transaction error handling in DynamoDB?

easy

A. To ensure all changes in a transaction happen together or not at all

B. To speed up query performance

C. To allow partial updates in a transaction

D. To automatically backup data after each transaction

Solution

1. Step 1: Understand transaction atomicity

   Transactions in DynamoDB ensure that either all operations succeed or none do, preventing partial updates.

2. Step 2: Identify the role of error handling

   Error handling detects when a transaction fails and prevents inconsistent data states.

3. Final Answer:

   To ensure all changes in a transaction happen together or not at all -> Option A

4. Quick Check:

   Transaction atomicity = To ensure all changes in a transaction happen together or not at all [OK]

Hint: Remember: transactions are all-or-nothing operations [OK]

Common Mistakes:

• Thinking transactions allow partial success
• Confusing error handling with performance tuning
• Assuming automatic backups happen on errors

2. Which of the following is the correct way to catch a transaction error in DynamoDB using JavaScript?

easy

A. try { await client.transactWrite(params); } catch (error) { if (error.code === 'TransactionCanceledException') { /* handle */ } }

B. await client.transactWrite(params).catch(error => if error.code == 'TransactionCanceledException' { /* handle */ })

C. try { client.transactWrite(params); } catch error { if error.code = 'TransactionCanceledException' { /* handle */ } }

D. client.transactWrite(params).then().catch(error => if (error.code === 'TransactionCanceledException') { /* handle */ })

Solution

1. Step 1: Check syntax for try-catch with async/await

   try { await client.transactWrite(params); } catch (error) { if (error.code === 'TransactionCanceledException') { /* handle */ } } correctly uses try-catch with await and compares error.code with 'TransactionCanceledException'.

2. Step 2: Identify syntax errors in other options

   await client.transactWrite(params).catch(error => if error.code == 'TransactionCanceledException' { /* handle */ }) has incorrect arrow function syntax; try { client.transactWrite(params); } catch error { if error.code = 'TransactionCanceledException' { /* handle */ } } misses parentheses and uses wrong assignment; client.transactWrite(params).then().catch(error => if (error.code === 'TransactionCanceledException') { /* handle */ }) uses then() without await which is less clear.

3. Final Answer:

   try { await client.transactWrite(params); } catch (error) { if (error.code === 'TransactionCanceledException') { /* handle */ } } -> Option A

4. Quick Check:

   Correct try-catch syntax = try { await client.transactWrite(params); } catch (error) { if (error.code === 'TransactionCanceledException') { /* handle */ } } [OK]

Hint: Use try-catch with await and check error.code string [OK]

Common Mistakes:

• Missing parentheses in catch block
• Using assignment '=' instead of comparison '==='
• Incorrect arrow function syntax in catch

3. Given this code snippet, what will be the output if the transaction fails due to a conditional check failure?

try {
  await client.transactWrite(params);
  console.log('Transaction succeeded');
} catch (error) {
  if (error.code === 'TransactionCanceledException') {
    console.log('Transaction failed: ' + error.message);
  } else {
    console.log('Other error');
  }
}

medium

A. Other error

B. Transaction succeeded

C. Transaction failed: ConditionalCheckFailed

D. No output

Solution

1. Step 1: Understand error handling flow

   If the transaction fails due to a conditional check, DynamoDB throws TransactionCanceledException with a message indicating ConditionalCheckFailed.

2. Step 2: Trace the catch block output

   The catch block checks error.code and prints 'Transaction failed: ' plus the error message, so it outputs the failure message.

3. Final Answer:

   Transaction failed: ConditionalCheckFailed -> Option C

4. Quick Check:

   Error code check prints failure message = Transaction failed: ConditionalCheckFailed [OK]

Hint: TransactionCanceledException means failure message logs [OK]

Common Mistakes:

• Assuming success message prints on failure
• Ignoring error.code check
• Confusing error messages with other exceptions

4. Identify the error in this DynamoDB transaction error handling code snippet:

try {
  client.transactWrite(params);
} catch (error) {
  if (error.code === 'TransactionCanceledException') {
    console.log('Transaction failed');
  }
}

medium

A. Try block should not be used with transactWrite

B. Incorrect error code string in if condition

C. Using console.log inside catch is invalid

D. Missing await before client.transactWrite causing unhandled promise

Solution

1. Step 1: Check async call handling

   client.transactWrite returns a promise; without await, errors won't be caught by try-catch.

2. Step 2: Confirm error handling correctness

   The error code string and console.log usage are correct; try-catch is valid for async with await.

3. Final Answer:

   Missing await before client.transactWrite causing unhandled promise -> Option D

4. Quick Check:

   Async calls need await for try-catch to work [OK]

Hint: Always await async calls inside try to catch errors [OK]

Common Mistakes:

• Omitting await on async functions
• Misnaming error codes
• Thinking console.log is disallowed in catch

5. You want to retry a DynamoDB transaction only if it fails due to a TransactionCanceledException caused by a conditional check failure. Which approach correctly implements this retry logic?

hard

A. Use try-catch but do not check error code; retry only once

B. Use a loop with try-catch; inside catch, check if error.code is 'TransactionCanceledException' and error.message contains 'ConditionalCheckFailed', then retry up to max attempts

C. Retry unconditionally on any error without checking error type

D. Ignore errors and assume transaction will succeed eventually

Solution

1. Step 1: Understand selective retry conditions

   Retry should happen only if error.code is 'TransactionCanceledException' and message indicates conditional check failure.

2. Step 2: Implement retry with loop and max attempts

   Use a loop with try-catch, check error details, and retry up to a limit to avoid infinite loops.

3. Final Answer:

   Use a loop with try-catch; inside catch, check if error.code is 'TransactionCanceledException' and error.message contains 'ConditionalCheckFailed', then retry up to max attempts -> Option B

4. Quick Check:

   Retry only on specific error with loop and checks = Use a loop with try-catch; inside catch, check if error.code is 'TransactionCanceledException' and error.message contains 'ConditionalCheckFailed', then retry up to max attempts [OK]

Hint: Retry only on specific error codes and messages [OK]

Common Mistakes:

• Retrying on all errors causing infinite loops
• Not checking error.message for conditional failure
• Ignoring max retry limits