Why CRUD operations are foundational in DynamoDB - Performance Analysis

Time Complexity: Why CRUD operations are foundational

O(1)

Understanding Time Complexity

CRUD operations are the basic actions we do with data in DynamoDB. Understanding their time cost helps us see how fast or slow our app can be as data grows.

We want to know how the work done changes when we add more data.

Scenario Under Consideration

Analyze the time complexity of the following DynamoDB CRUD operations.

// Create (PutItem)
await dynamoDb.put({ TableName: 'Users', Item: user }).promise();

// Read (GetItem)
const result = await dynamoDb.get({ TableName: 'Users', Key: { userId } }).promise();

// Update (UpdateItem)
await dynamoDb.update({ TableName: 'Users', Key: { userId }, UpdateExpression: 'set age = :a', ExpressionAttributeValues: { ':a': 30 } }).promise();

// Delete (DeleteItem)
await dynamoDb.delete({ TableName: 'Users', Key: { userId } }).promise();
    

This code shows the four main operations: adding, reading, changing, and removing a single item by its key.

Identify Repeating Operations

Look for repeated work inside these operations.

• Primary operation: Accessing a single item by its key.
• How many times: Each operation touches exactly one item once.

How Execution Grows With Input

Each CRUD operation works directly with one item using its key, so the time to complete does not grow with the total number of items.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The work stays the same no matter how many items are in the table.

Final Time Complexity

Time Complexity: O(1)

This means each CRUD operation takes about the same time regardless of how much data is stored.

Common Mistake

[X] Wrong: "CRUD operations get slower as the table grows because they scan all items."

[OK] Correct: Each operation uses the item's key to directly find it, so it does not look through all items.

Interview Connect

Knowing that CRUD operations run in constant time helps you explain how DynamoDB handles data efficiently. This shows you understand the basics of fast data access.

Self-Check

"What if we replaced GetItem with a Scan operation? How would the time complexity change?"

Practice

1. What does the CRUD acronym stand for in database operations?

easy

A. Calculate, Remove, Upload, Download

B. Create, Read, Update, Delete

C. Copy, Run, Undo, Drop

D. Connect, Retrieve, Use, Delete

Solution

1. Step 1: Understand each letter in CRUD

   CRUD stands for the four basic operations to manage data: Create, Read, Update, and Delete.

2. Step 2: Match the correct full form

   Among the options, only Create, Read, Update, Delete correctly lists these four operations.

3. Final Answer:

   Create, Read, Update, Delete -> Option B

4. Quick Check:

   CRUD = Create, Read, Update, Delete [OK]

Hint: Remember CRUD as the four main data actions [OK]

Common Mistakes:

• Confusing CRUD with unrelated terms
• Mixing up the order of operations
• Thinking CRUD includes 'Copy' or 'Calculate'

2. Which of the following is the correct syntax to add a new item in DynamoDB using the AWS SDK?

easy

A. dynamodb.putItem({ TableName: 'Users', Item: { 'UserId': { S: '123' } } })

B. dynamodb.getItem({ TableName: 'Users', Key: { 'UserId': { S: '123' } } })

C. dynamodb.deleteItem({ TableName: 'Users', Key: { 'UserId': { S: '123' } } })

D. dynamodb.updateItem({ TableName: 'Users', Key: { 'UserId': { S: '123' } } })

Solution

1. Step 1: Identify the operation to add a new item

   Adding a new item uses the putItem method in DynamoDB.

2. Step 2: Match the correct syntax

   dynamodb.putItem({ TableName: 'Users', Item: { 'UserId': { S: '123' } } }) uses putItem with the correct parameters to add an item.

3. Final Answer:

   dynamodb.putItem({ TableName: 'Users', Item: { 'UserId': { S: '123' } } }) -> Option A

4. Quick Check:

   Adding item = putItem [OK]

Hint: Use putItem to create new data in DynamoDB [OK]

Common Mistakes:

• Using getItem or deleteItem to add data
• Confusing Key with Item in parameters
• Missing TableName or Item fields

3. Given the following DynamoDB operation, what will be the result?

const params = { TableName: 'Books', Key: { 'ISBN': { S: '978-1234567890' } } };
const data = await dynamodb.getItem(params).promise();
console.log(data.Item);

medium

A. It will cause a syntax error

B. It will delete the item with ISBN '978-1234567890'

C. It will update the item with ISBN '978-1234567890'

D. It will print the item with ISBN '978-1234567890' if it exists

Solution

1. Step 1: Understand the getItem operation

   The getItem method retrieves an item by its key from the table.

2. Step 2: Analyze the code output

   The code logs data.Item, which will be the item with the given ISBN if it exists, or undefined if not.

3. Final Answer:

   It will print the item with ISBN '978-1234567890' if it exists -> Option D

4. Quick Check:

   getItem returns item data [OK]

Hint: getItem fetches data; console.log prints it [OK]

Common Mistakes:

• Thinking getItem deletes or updates data
• Assuming syntax error due to async/await
• Confusing Key with Item in parameters

4. You wrote this DynamoDB update code but it throws an error:

const params = {
  TableName: 'Users',
  Key: { 'UserId': { S: 'abc123' } },
  UpdateExpression: 'set Age = :age',
  ExpressionAttributeValues: { ':age': 30 }
};
await dynamodb.updateItem(params).promise();

What is the likely cause of the error?

medium

A. ExpressionAttributeValues must use DynamoDB types like { ':age': { N: '30' } }

B. UpdateExpression should be 'update Age = :age'

C. Key should be inside Item property

D. TableName is missing

Solution

1. Step 1: Check ExpressionAttributeValues format

   DynamoDB expects attribute values to be typed, e.g., numbers as { N: '30' }.

2. Step 2: Identify the error cause

   The code uses a plain number 30 instead of the typed format, causing a validation error.

3. Final Answer:

   ExpressionAttributeValues must use DynamoDB types like { ':age': { N: '30' } } -> Option A

4. Quick Check:

   Use typed values in ExpressionAttributeValues [OK]

Hint: Always wrap values with DynamoDB types in updates [OK]

Common Mistakes:

• Using raw JS values instead of typed DynamoDB values
• Wrong UpdateExpression syntax
• Misplacing Key inside Item

5. You want to delete a user from a DynamoDB table only if their account is inactive. Which approach correctly combines CRUD operations to achieve this safely?

hard

A. Use putItem to overwrite the user with an empty item

B. Use updateItem to set AccountStatus to 'deleted' without conditions

C. Use deleteItem with a ConditionExpression checking if AccountStatus = 'inactive'

D. Use getItem to read then deleteItem without conditions

Solution

1. Step 1: Understand safe deletion with conditions

   To delete only if a condition is met, use deleteItem with a ConditionExpression.

2. Step 2: Evaluate options for correctness

   Use deleteItem with a ConditionExpression checking if AccountStatus = 'inactive' uses deleteItem with a condition to delete only inactive accounts, which is safe and efficient.

3. Final Answer:

   Use deleteItem with a ConditionExpression checking if AccountStatus = 'inactive' -> Option C

4. Quick Check:

   Conditional delete = deleteItem + ConditionExpression [OK]

Hint: Use ConditionExpression to safely delete items [OK]

Common Mistakes:

• Deleting without checking account status
• Using updateItem to delete data
• Overwriting with putItem instead of deleting