AI-200 practice: Connect to Azure Cosmos DB for NoSQL by using the SDK and run queries

Question 1

You need to perform a conditional update on a Cosmos DB item — increment a `viewCount` field without overwriting other fields, and only if the item hasn't changed since it was last read (optimistic concurrency).

Which implementation correctly satisfies both requirements?

Accepted Answer

item = container.read_item(item="doc1", partition_key="tenant-a")
etag = item["_etag"]

container.patch_item(
    item="doc1",
    partition_key="tenant-a",
    patch_operations=[{"op": "incr", "path": "/viewCount", "value": 1}],
    etag=etag,
    match_condition=MatchConditions.IfNotModified
)

Answer

item = container.read_item(item="doc1", partition_key="tenant-a")
item["viewCount"] = item.get("viewCount", 0) + 1
container.replace_item(item="doc1", body=item)

Answer

item = container.read_item(item="doc1", partition_key="tenant-a")
item["viewCount"] += 1
container.upsert_item(body=item)

Answer

item = container.read_item(item="doc1", partition_key="tenant-a")
container.replace_item(
    item="doc1",
    body={"viewCount": item.get("viewCount", 0) + 1}
)

Question 2

You need to page through query results using continuation tokens in a background export job that must resume after a restart:
```python
query = "SELECT * FROM c WHERE c.status = 'active'"
query_iterable = container.query_items(
    query=query,
    partition_key="tenant-a",
    max_item_count=100
)
pager = query_iterable.by_page(continuation_token=saved_token)
for page in pager:
    for item in page:
        process(item)
    # TODO: persist token for resume
```
What is the correct way to persist the continuation token so the job can resume exactly where it left off after a crash?

Accepted Answer

Save pager.continuation_token after each page is fully processed, since by_page()'s pager object exposes the token needed to resume from that exact page boundary on the next by_page(continuation_token=...) call.

Answer

Save page[-1]["id"] (the last item's id) and use it as a WHERE c.id > @lastId filter on resume instead of a continuation token.

Answer

Continuation tokens are not supported by the Python SDK; use OFFSET/LIMIT instead for resumable pagination.

Answer

Save the token before processing each page (i.e., before the for item in page loop) rather than after.

Question 3

You run this Cosmos DB SQL query to find documents where a nested array contains a specific tag, using a subquery:
```sql
SELECT c.id, c.title
FROM c
WHERE EXISTS (
  SELECT VALUE t
  FROM t IN c.tags
  WHERE t = "urgent"
)
```
A colleague suggests rewriting it using ARRAY_CONTAINS for better performance. Which rewritten query is both correct and more efficient?

Accepted Answer

SELECT c.id, c.title FROM c WHERE ARRAY_CONTAINS(c.tags, "urgent")

Answer

SELECT c.id, c.title FROM c WHERE c.tags CONTAINS "urgent"

Answer

SELECT c.id, c.title FROM c WHERE "urgent" IN c.tags

Answer

SELECT c.id, c.title FROM c JOIN t IN c.tags WHERE t = "urgent"

Question 4

You perform a transactional batch operation to insert an order and update inventory atomically within the same partition:
```python
from azure.cosmos import TransactionalBatch

batch_operations = [
    ("create", (order_item,)),
    ("replace", ("inventory-sku123", updated_inventory_item))
]
batch_response = container.execute_item_batch(
    batch_operations=batch_operations,
    partition_key="store-42"
)
```
This raises an error at runtime. What is the most likely cause?

Accepted Answer

Transactional batch operations require all items in the batch to belong to the same logical partition key, and if order_item or updated_inventory_item has a different /partitionKey value than "store-42" (e.g., the order is keyed by customerId instead of storeId), the batch fails.

Answer

execute_item_batch is not a real method; batches must be constructed as raw SQL transactions using BEGIN TRANSACTION.

Answer

Transactional batches are limited to create operations only; replace cannot be mixed into the same batch.

Answer

Batches require exactly 2 operations; adding a third would also fail.

Question 5

You perform bulk data ingestion of 500,000 embedding chunks into Cosmos DB using the Python SDK and need to maximize throughput while handling rate-limiting gracefully:
```python
client = CosmosClient(url, credential=key)
container = client.get_database_client("ragdb").get_container_client("chunks")

for chunk in all_chunks:
    container.create_item(body=chunk)
```
This sequential loop is extremely slow and occasionally throws CosmosHttpResponseError with status code 429. What two changes best address throughput and reliability?

Accepted Answer

Enable bulk execution mode on the client (or using asyncio-based concurrent create_item calls) to parallelize writes, and rely on the SDK's built-in automatic retry policy for 429 responses rather than failing immediately.

Answer

Switch to synchronous single-threaded writes with time.sleep(1) between every call; this is the only supported way to avoid 429 errors.

Answer

Increase max_item_count on create_item calls to insert multiple items per call; create_item supports batched arrays natively for bulk loads.

Answer

Disable indexing checks client-side by passing no_response=True; this prevents 429 errors by skipping server validation.

Question 6

Your Python application must connect to Azure Cosmos DB for NoSQL using Microsoft Entra ID rather than a primary key. Which SDK construct should you use?

Accepted Answer

CosmosClient(url, credential=DefaultAzureCredential())

Answer

CosmosClient(url, credential=primary_key_string)

Answer

requests.get(url, headers={"key": primary_key})

Answer

CosmosClient.from_connection_string(conn_str)

Question 7

Which Cosmos DB for NoSQL SDK method is used to execute a parameterized SQL query against a container from Python?

Accepted Answer

container.query_items(query=..., parameters=[...])

Answer

container.upsert_item(body=document_payload)

Answer

container.read_item(item=..., partition_key=...)

Answer

container.delete_item(item=..., partition_key=...)

Question 8

A .NET Azure Function creates a `new CosmosClient(endpoint, credential)` at the start of every invocation and disposes it at the end. Under load, p99 latency climbs and the instance logs socket and port exhaustion warnings. What is the recommended fix?

Accepted Answer

Create one CosmosClient for the app's lifetime (a static or DI singleton) and reuse it for every invocation

Answer

Switch the client to Gateway connection mode while still creating a client for each invocation

Answer

Increase the container's provisioned RU/s so each new client connects faster

Answer

Call client.Dispose() earlier, right after the first query, so sockets are released sooner

Question 9

A chat service needs to load one conversation document. It already knows the document's `id` (`conv-981`) and partition key value (`user-42`). Which Python SDK call returns the document at the lowest RU cost?

Accepted Answer

container.read_item(item='conv-981', partition_key='user-42')

Answer

container.query_items("SELECT * FROM c WHERE c.id = 'conv-981'", enable_cross_partition_query=True)

Answer

container.query_items("SELECT * FROM c WHERE c.id = 'conv-981'", partition_key='user-42')

Answer

container.read_all_items(), then filter on id in Python

Question 10

A Python app connects to Cosmos DB with `CosmosClient(url, credential=DefaultAzureCredential())`. At startup it calls `create_database_if_not_exists` and `create_container_if_not_exists`, then runs queries. Local (key) authentication is disabled on the account. Every call fails with 403 Forbidden. Which two changes fix this while keeping Microsoft Entra authentication? Select two.

Accepted Answer

Create a Cosmos DB data-plane role assignment for the app identity, for example with the Cosmos DB Built-in Data Contributor role through az cosmosdb sql role assignment create

Accepted Answer

Provision the database and container through the control plane (Bicep, ARM, or the CLI) and remove the create_*_if_not_exists calls from the app

Answer

Assign the Azure RBAC Contributor role on the Cosmos DB account to the app identity; this also grants data access

Answer

Re-enable local authentication and pass the primary key to CosmosClient

Answer

Set the account's default consistency level to Strong

11 questions