Boto3 (Python) client vs resource in DynamoDB - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference in method usage between client and resource

Which statement correctly describes how you would retrieve an item from a DynamoDB table using Boto3 client vs resource?

A Client uses get_item with TableName parameter; resource uses Table object with get_item method without TableName.

B Client and resource do not support get_item method.

C Both client and resource require TableName parameter in get_item method.

D Client uses Table object with get_item method; resource uses get_item with TableName parameter.

💡 Hint

Think about how client and resource interfaces differ in method calls.

The client interface requires explicit parameters like TableName in methods such as get_item. The resource interface provides higher-level abstractions like Table objects where methods like get_item do not require TableName because the Table object already represents a specific table.

❓ query_result

intermediate

Output of scan operation using client vs resource

Given the following code snippets, what is the type of the output returned by each scan operation? Client: ```python dynamodb_client = boto3.client('dynamodb') response = dynamodb_client.scan(TableName='MyTable') ``` Resource: ```python dynamodb_resource = boto3.resource('dynamodb') table = dynamodb_resource.Table('MyTable') response = table.scan() ```

A Client returns a dict with raw DynamoDB JSON; resource returns a dict with Python native types.

B Client returns a list of items; resource returns a dict with raw DynamoDB JSON.

C Both client and resource return a list of items as Python dicts.

D Client returns a dict with Python native types; resource returns a list of items.

💡 Hint

Consider how Boto3 client and resource handle data types in responses.

The client returns raw DynamoDB JSON format where attribute values are typed (e.g., {'S': 'string'}). The resource automatically converts these into native Python types (e.g., strings, numbers) in the returned dict.

📝 Syntax

advanced

Correct syntax to update an item using resource

Which of the following code snippets correctly updates an attribute 'status' to 'active' for a given key in a DynamoDB table using Boto3 resource?

A table.update_item(Key={'id': '123'}, UpdateExpression='SET status = active')

B table.update_item(Key={'id': '123'}, UpdateExpression='SET status = :val', ExpressionAttributeValues={':val': {'S': 'active'}})

C table.update_item(Key={'id': '123'}, UpdateExpression='SET status = :val', ExpressionAttributeValues={':val': 'active'})

D table.update_item(Key={'id': '123'}, UpdateExpression='SET status = :val', ExpressionAttributeValues={':val': active})

💡 Hint

Remember how resource expects Python native types in ExpressionAttributeValues.

When using resource, ExpressionAttributeValues should be Python native types, not DynamoDB JSON format. Option C correctly uses a string value 'active'. Option C incorrectly uses DynamoDB JSON format. Option C misses ExpressionAttributeValues. Option C uses an undefined variable active.

❓ optimization

advanced

Choosing client or resource for batch writes

You want to write 1000 items to a DynamoDB table efficiently. Which approach is better and why?

A Use resource's put_item method for each item because it is simpler.

B Use resource's batch_writer() because it automatically handles buffering and retries.

C Use client put_item in a loop because it gives more control over each write.

D Use client batch_write_item with single item per request for simplicity.

💡 Hint

Think about how batch_writer helps with large writes.

Resource's batch_writer() manages buffering, batch sizes, and retries automatically, making it efficient for large writes. Client requires manual batching and retry logic, which is more complex and error-prone.

🔧 Debug

expert

Why does this client code raise a ValidationException?

Consider this client code snippet: ```python response = dynamodb_client.get_item(Key={'id': '123'}, TableName='MyTable') ``` It raises a ValidationException with message: "One or more parameter values were invalid: Type mismatch for key id expected: S actual: N". What is the cause?

A The key value '123' is passed as a plain string instead of DynamoDB JSON format with type.

B The TableName parameter is missing from the get_item call.

C The key attribute 'id' is missing from the Key dictionary.

D The key value type does not match the table's key schema; it expects a string but got a number.

💡 Hint

Check the expected data type of the key attribute in the table schema.

The error indicates a type mismatch: the table expects a string (S) for the 'id' key, but the actual value is a number (N). Passing '123' as a plain string without DynamoDB JSON format is correct for resource but client expects the value wrapped with type. However, the main issue is the type mismatch between expected and actual key type.

Practice

1. What is the main difference between Boto3 client and resource when working with DynamoDB?

easy

A. client is deprecated, resource is the new standard.

B. client is only for S3, resource is only for DynamoDB.

C. client is low-level and matches AWS API calls exactly, while resource is higher-level and easier to use.

D. client automatically manages retries, resource does not.

Solution

1. Step 1: Understand the roles of client and resource

   The client provides direct access to AWS service APIs with low-level calls, matching the exact API structure.

2. Step 2: Compare with resource abstraction

   The resource offers a higher-level, object-oriented interface that simplifies interactions with AWS services like DynamoDB.

3. Final Answer:

   client is low-level and matches AWS API calls exactly, while resource is higher-level and easier to use. -> Option C

4. Quick Check:

   client = low-level, resource = high-level [OK]

Hint: Client = low-level API, resource = easier Python objects [OK]

Common Mistakes:

• Thinking client is deprecated
• Confusing client and resource usage scope
• Assuming resource has full API coverage

2. Which of the following is the correct way to create a DynamoDB resource using Boto3 in Python?

easy

A. dynamodb = boto3.client('dynamodb')

B. dynamodb = boto3.resource('dynamodb')

C. dynamodb = boto3.connect('dynamodb')

D. dynamodb = boto3.session('dynamodb')

Solution

1. Step 1: Recall Boto3 resource creation syntax

   To create a resource, use boto3.resource('service_name'). For DynamoDB, it is boto3.resource('dynamodb').

2. Step 2: Identify incorrect options

   boto3.client('dynamodb') creates a client, not a resource. connect and session are not valid Boto3 methods for this purpose.

3. Final Answer:

   dynamodb = boto3.resource('dynamodb') -> Option B

4. Quick Check:

   Resource creation uses boto3.resource('service') [OK]

Hint: Use boto3.resource('dynamodb') for resource creation [OK]

Common Mistakes:

• Using boto3.client instead of boto3.resource
• Trying to use boto3.connect which doesn't exist
• Confusing session with resource creation

3. Given the following code snippet using Boto3 resource:

import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')
response = table.get_item(Key={'UserId': '123'})
print(response['Item']['Name'])

What will this code print if the item exists with Name 'Alice'?

medium

A. 123

B. None

C. KeyError

D. Alice

Solution

1. Step 1: Understand the get_item call on resource Table

   The get_item method returns a dictionary with an 'Item' key containing the requested item if it exists.

2. Step 2: Access the 'Name' attribute from the returned item

   The code prints response['Item']['Name'], which will be 'Alice' if the item exists with that attribute.

3. Final Answer:

   Alice -> Option D

4. Quick Check:

   response['Item']['Name'] = Alice [OK]

Hint: get_item returns dict with 'Item' key holding data [OK]

Common Mistakes:

• Assuming response is just the item dict
• Forgetting to check 'Item' key
• Confusing client and resource response formats

4. What is wrong with this Boto3 client code snippet for DynamoDB?

import boto3
client = boto3.client('dynamodb')
response = client.get_item(TableName='Users', Key={'UserId': '123'})
print(response['Item'])

medium

A. The Key value should be a dict with attribute type, e.g., {'UserId': {'S': '123'}}

B. TableName should be lowercase 'users'

C. client.get_item does not exist, use resource instead

D. print statement should be print(response.Item)

Solution

1. Step 1: Check the Key format for client get_item

   When using the low-level client, the Key must specify attribute types, e.g., {'UserId': {'S': '123'}}.

2. Step 2: Identify other issues

   TableName is case-sensitive and usually capitalized as in the table creation. The method get_item exists on client. The print syntax is correct for a dict.

3. Final Answer:

   The Key value should be a dict with attribute type, e.g., {'UserId': {'S': '123'}} -> Option A

4. Quick Check:

   Client Key needs attribute type dict [OK]

Hint: Client Key needs attribute type dict like {'S': 'value'} [OK]

Common Mistakes:

• Using simple dict for Key with client
• Assuming client and resource Key formats are same
• Ignoring case sensitivity of TableName

5. You want to update an item attribute in DynamoDB using Boto3. Which approach correctly uses the resource and client to update the attribute 'Age' to 30 for UserId '123'?

hard

A. Resource: table.update_item(Key={'UserId': '123'}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': 30})
Client: client.update_item(TableName='Users', Key={'UserId': {'S': '123'}}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': {'N': '30'}})

B. Resource: table.update_item(Key={'UserId': {'S': '123'}}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': {'N': '30'}})
Client: client.update_item(TableName='Users', Key={'UserId': '123'}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': 30})

C. Resource: table.put_item(Item={'UserId': '123', 'Age': 30})
Client: client.put_item(TableName='Users', Item={'UserId': {'S': '123'}, 'Age': {'N': '30'}})

D. Resource: table.update_item(Key={'UserId': '123'}, UpdateExpression='ADD Age :val', ExpressionAttributeValues={':val': 30})
Client: client.update_item(TableName='Users', Key={'UserId': {'S': '123'}}, UpdateExpression='ADD Age :val', ExpressionAttributeValues={':val': {'N': '30'}})

Solution

1. Step 1: Understand resource update_item usage

   Resource expects simple Python types for Key and ExpressionAttributeValues, so {'UserId': '123'} and {':val': 30} are correct.

2. Step 2: Understand client update_item usage

   Client requires attribute types in Key and ExpressionAttributeValues, so {'UserId': {'S': '123'}} and {':val': {'N': '30'}} are needed.

3. Step 3: Confirm UpdateExpression syntax

   Using SET Age = :val is correct for updating an attribute value.

4. Final Answer:

   Resource and client update_item calls with correct Key and ExpressionAttributeValues formats as in option A -> Option A

5. Quick Check:

   Resource uses plain types, client uses typed dicts [OK]

Hint: Resource uses plain dicts; client needs typed attribute dicts [OK]

Common Mistakes:

• Mixing client and resource Key formats
• Using ADD instead of SET for update
• Passing raw values in client ExpressionAttributeValues