Transaction error handling in DynamoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a transaction in DynamoDB.

DynamoDB

const params = { TransactItems: [[1]] };

Drag options to blanks, or click blank then click option'

A{ Get: { TableName: 'Users', Key: { UserId: '123' } } }

B{ Put: { TableName: 'Users', Item: { UserId: '123' } } }

C{ Delete: { TableName: 'Users', Key: { UserId: '123' } } }

D{ Update: { TableName: 'Users', Key: { UserId: '123' }, UpdateExpression: 'SET Age = :age' } }

Attempts:

3 left

💡 Hint

Common Mistakes

Using Get operation inside TransactItems which is not supported.

Forgetting to wrap the operation inside an object with the operation name as key.

The TransactItems array requires transaction operations like Put. Here, we start with a Put operation.

2fill in blank

medium

Complete the code to catch a transaction cancellation error.

DynamoDB

try {
  await dynamodb.transactWrite(params).promise();
} catch (error) {
  if (error.code === [1]) {
    console.log('Transaction cancelled');
  }
}

Drag options to blanks, or click blank then click option'

A'InternalServerError'

B'ConditionalCheckFailedException'

C'ProvisionedThroughputExceededException'

D'TransactionCanceledException'

Attempts:

3 left

💡 Hint

Common Mistakes

Using ConditionalCheckFailedException which is for condition failures, not transaction cancellation.

Checking for wrong error codes that do not relate to transactions.

The error code TransactionCanceledException indicates a transaction was cancelled in DynamoDB.

3fill in blank

hard

Fix the error in the transaction retry logic by completing the blank.

DynamoDB

let retries = 0;
const maxRetries = 3;
while (retries < maxRetries) {
  try {
    await dynamodb.transactWrite(params).promise();
    break;
  } catch (error) {
    if (error.code === 'TransactionCanceledException' && retries < [1]) {
      retries++;
    } else {
      throw error;
    }
  }
}

Drag options to blanks, or click blank then click option'

AmaxRetries

B5

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using a hardcoded number that does not match maxRetries.

Using zero which prevents any retries.

The retry condition should compare retries with maxRetries to limit retry attempts properly.

4fill in blank

hard

Fill both blanks to check if the transaction error is retryable and log the error message.

DynamoDB

if (error.code === [1]) {
  console.log('Retryable error:', error.[2]);
}

Drag options to blanks, or click blank then click option'

A'TransactionCanceledException'

Bmessage

Ccode

Dstack

Attempts:

3 left

💡 Hint

Common Mistakes

Logging the error code instead of the message.

Checking for wrong error codes.

Check for TransactionCanceledException to identify retryable errors and log the message property for details.

5fill in blank

hard

Fill all three blanks to build a transaction with condition check, put, and handle cancellation error.

DynamoDB

const params = {
  TransactItems: [
    { ConditionCheck: { TableName: 'Orders', Key: { OrderId: '001' }, ConditionExpression: [1] } },
    { Put: { TableName: 'Orders', Item: { OrderId: '002', Status: 'Pending' } } }
  ]
};

try {
  await dynamodb.transactWrite(params).promise();
} catch (error) {
  if (error.code === [2]) {
    console.log('Transaction failed:', error.[3]);
  } else {
    throw error;
  }
}

Drag options to blanks, or click blank then click option'

A'attribute_not_exists(OrderId)'

B'TransactionCanceledException'

Cmessage

D'attribute_exists(OrderId)'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'attribute_exists' which would fail if the item does not exist.

Logging the error code instead of the message.

The condition expression ensures the order does not exist before putting a new one. The error code TransactionCanceledException is caught and the error message is logged.

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