Transaction conditions in DynamoDB - Mini Project: Build & Apply

DynamoDB Transaction Conditions

📖 Scenario: You are managing a simple inventory system for a small store. You want to update the stock quantity of a product only if the current stock matches a specific value, to avoid overwriting changes made by others.

🎯 Goal: Build a DynamoDB transaction that updates the stock quantity of a product only if the current stock quantity matches the expected value, using transaction conditions.

📋 What You'll Learn

Create a DynamoDB table named Products with ProductID as the primary key.

Set up an initial item with ProductID 'P1001' and Stock 50.

Define a transaction condition to check that the current Stock is 50 before updating.

Update the Stock to 45 only if the condition is met.

💡 Why This Matters

🌍 Real World

Inventory management systems often require safe updates to stock levels to prevent conflicts when multiple users or systems update the same data.

💼 Career

Understanding DynamoDB transactions and condition expressions is essential for backend developers working with AWS to ensure data consistency and integrity.

1

Create the initial item in the Products table

Write a DynamoDB PutItem request to add an item to the Products table with ProductID set to 'P1001' and Stock set to 50.

DynamoDB

# Your PutItem request here

Hint

Use PutItem with TableName 'Products' and set ProductID and Stock attributes.

2

Define the transaction condition for stock check

Create a condition expression variable named conditionExpression that checks if the Stock attribute equals 50.

DynamoDB

PutItem {
  TableName: "Products",
  Item: {
    "ProductID": { S: "P1001" },
    "Stock": { N: "50" }
  }
}

# Define conditionExpression to check Stock equals 50

Hint

Use a condition expression string and an expression attribute value for 50.

3

Create the transaction update with condition

Write a DynamoDB TransactWriteItems request that updates the Stock attribute to 45 for ProductID 'P1001' only if the conditionExpression is true.

DynamoDB

PutItem {
  TableName: "Products",
  Item: {
    "ProductID": { S: "P1001" },
    "Stock": { N: "50" }
  }
}

conditionExpression = "Stock = :expectedStock"
ExpressionAttributeValues = { ":expectedStock": { N: "50" } }

# Write TransactWriteItems request with Update and ConditionExpression

Hint

Use TransactWriteItems with an Update action including ConditionExpression and UpdateExpression.

4

Complete the transaction with final attributes

Add the final ExpressionAttributeValues to the transaction update to include both :newStock as 45 and :expectedStock as 50.

DynamoDB

PutItem {
  TableName: "Products",
  Item: {
    "ProductID": { S: "P1001" },
    "Stock": { N: "50" }
  }
}

conditionExpression = "Stock = :expectedStock"
ExpressionAttributeValues = { ":expectedStock": { N: "50" } }

TransactWriteItems {
  TransactItems: [
    {
      Update: {
        TableName: "Products",
        Key: { "ProductID": { S: "P1001" } },
        UpdateExpression: "SET Stock = :newStock",
        ConditionExpression: conditionExpression,
        ExpressionAttributeValues: {
          # Add both :newStock and :expectedStock here
        }
      }
    }
  ]
}

Hint

Include both :newStock and :expectedStock in ExpressionAttributeValues.

Practice

1. What is the main purpose of using ConditionCheck in a DynamoDB transaction?

easy

A. To ensure certain conditions are met before making changes to data

B. To speed up the transaction by skipping checks

C. To delete all items in a table

D. To create a backup of the database

Solution

1. Step 1: Understand ConditionCheck role

   ConditionCheck verifies if specified conditions are true before allowing a transaction to proceed.

2. Step 2: Recognize transaction safety

   If conditions fail, the transaction is aborted, preventing unwanted data changes.

3. Final Answer:

   To ensure certain conditions are met before making changes to data -> Option A

4. Quick Check:

   Transaction conditions = safety check [OK]

Hint: ConditionCheck = verify before change [OK]

Common Mistakes:

• Thinking ConditionCheck speeds up transactions
• Confusing ConditionCheck with data deletion
• Assuming ConditionCheck creates backups

2. Which of the following is the correct syntax snippet for a ConditionCheck in a DynamoDB transaction?

easy

A. "ConditionCheck": {"Key": {"Id": {"N": 123}}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"}

B. "ConditionCheck": {"Key": {"Id": "123"}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"}

C. "ConditionCheck": {"Key": {"Id": {"S": "123"}}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"}

D. "ConditionCheck": {"Key": {"Id": {"S": 123}}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"}

Solution

1. Step 1: Check key format for string type

   DynamoDB expects string values to be wrapped as {"S": "value"} in JSON.

2. Step 2: Validate ConditionExpression and TableName

   ConditionExpression uses attribute_exists correctly; TableName is properly specified.

3. Final Answer:

   "ConditionCheck": {"Key": {"Id": {"S": "123"}}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"} -> Option C

4. Quick Check:

   Correct JSON key format = "ConditionCheck": {"Key": {"Id": {"S": "123"}}, "TableName": "MyTable", "ConditionExpression": "attribute_exists(Id)"} [OK]

Hint: Use {"S": "string"} for string keys in ConditionCheck [OK]

Common Mistakes:

• Omitting the type wrapper like {"S": ...}
• Using number type for string keys
• Passing raw values without quotes

3. Given this transaction snippet, what happens if the item with Id = '101' does not exist?

{
  "TransactItems": [
    {
      "ConditionCheck": {
        "TableName": "Orders",
        "Key": {"Id": {"S": "101"}},
        "ConditionExpression": "attribute_exists(Id)"
      }
    },
    {
      "Update": {
        "TableName": "Orders",
        "Key": {"Id": {"S": "101"}},
        "UpdateExpression": "SET Status = :s",
        "ExpressionAttributeValues": {":s": {"S": "Processed"}}
      }
    }
  ]
}

medium

A. The update runs anyway, creating a new item

B. The transaction partially updates the item

C. The transaction ignores the ConditionCheck and updates

D. The transaction fails and no update happens

Solution

1. Step 1: Understand ConditionCheck with attribute_exists

   The ConditionCheck requires the item with Id '101' to exist for the transaction to proceed.

2. Step 2: Analyze transaction behavior on condition failure

   If the item does not exist, the condition fails, so the entire transaction is aborted and no update occurs.

3. Final Answer:

   The transaction fails and no update happens -> Option D

4. Quick Check:

   Condition failure aborts transaction = The transaction fails and no update happens [OK]

Hint: ConditionCheck failure stops whole transaction [OK]

Common Mistakes:

• Assuming update creates new item on failure
• Thinking transaction partially applies changes
• Ignoring ConditionCheck effect

4. You wrote this transaction but it always fails with a validation error:

{
  "TransactItems": [
    {
      "ConditionCheck": {
        "TableName": "Users",
        "Key": {"UserId": {"N": "abc"}},
        "ConditionExpression": "attribute_exists(UserId)"
      }
    }
  ]
}

What is the most likely cause?

medium

A. ConditionExpression syntax is wrong

B. The key type is incorrect; 'abc' is not a number

C. TableName is misspelled

D. ConditionCheck cannot be used alone

Solution

1. Step 1: Check key type and value

   The key uses type "N" (number) but the value "abc" is not numeric, causing validation error.

2. Step 2: Confirm other parts are correct

   ConditionExpression and TableName syntax are valid; ConditionCheck can be used alone.

3. Final Answer:

   The key type is incorrect; 'abc' is not a number -> Option B

4. Quick Check:

   Key type must match value format [OK]

Hint: Match key type with value format [OK]

Common Mistakes:

• Using non-numeric string with number type
• Assuming ConditionExpression syntax error
• Thinking ConditionCheck needs other actions

5. You want to update a user's email only if their current email is exactly '[e-mail]'. Which transaction condition setup achieves this safely?

hard

A. Use a ConditionCheck with ConditionExpression 'Email = :oldEmail' before the update

B. Use an Update with ConditionExpression 'attribute_exists(Email)'

C. Use a ConditionCheck with ConditionExpression 'attribute_not_exists(Email)'

D. Update without any condition; trust the data is correct

Solution

1. Step 1: Identify condition to match exact current email

   The condition must check that Email equals '[e-mail]' before updating.

2. Step 2: Use ConditionCheck to verify before update

   ConditionCheck with 'Email = :oldEmail' ensures update only happens if current email matches.

3. Final Answer:

   Use a ConditionCheck with ConditionExpression 'Email = :oldEmail' before the update -> Option A

4. Quick Check:

   Exact match condition before update = Use a ConditionCheck with ConditionExpression 'Email = :oldEmail' before the update [OK]

Hint: Check exact value with ConditionCheck before update [OK]

Common Mistakes:

• Using attribute_exists instead of exact match
• Checking attribute_not_exists which is opposite
• Skipping condition and risking wrong update