MongoDB integration with Motor in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find documents with a specific field value

Given a Motor collection with documents containing a field status, what will be the output of this query?

cursor = collection.find({"status": "active"})
results = await cursor.to_list(length=100)

Assume the collection has 3 documents with status set to "active".

FastAPI

cursor = collection.find({"status": "active"})
results = await cursor.to_list(length=100)

A An empty list because <code>to_list</code> requires a callback

B A list of all documents in the collection regardless of <code>status</code>

C A list of 3 documents where each document has <code>status</code> equal to <code>"active"</code>

D A single document with <code>status</code> equal to <code>"active"</code>

💡 Hint

Remember that find returns a cursor for all matching documents, and to_list collects them into a list.

The find method returns a cursor for all documents matching the filter. Using to_list with a length of 100 collects up to 100 matching documents into a list. Since there are 3 documents with status equal to "active", the result is a list of those 3 documents.

📝 Syntax

intermediate

Identify the syntax error in Motor query

Which option contains a syntax error when trying to update a document using Motor in FastAPI?

Code snippet:
await collection.update_one({"_id": id}, {"$set": {"name": "Alice"}})

A await collection.update_one({"_id": id}, {"$set": {"name": "Alice"}})

B await collection.update_one({"_id": id}, {"$set": {"name": "Alice"}});

C await collection.update_one({"_id": id}, {"$set": {"name": "Alice"}}

D await collection.update_one({"_id": id}, {"$set": {"name": "Alice"}}))

💡 Hint

Check for unmatched parentheses or extra characters.

Option D has an extra closing parenthesis at the end, causing a syntax error. Options A and D are syntactically correct (Python allows semicolons but they are optional). Option D is missing a closing parenthesis, also a syntax error but different from C.

❓ optimization

advanced

Optimize fetching large data sets with Motor

You want to fetch 10,000 documents from a Motor collection efficiently. Which approach is best to avoid high memory usage?

A Use <code>async for doc in collection.find():</code> to process documents one by one.

B Use <code>await collection.find().to_list(length=10000)</code> to get all documents at once.

C Use <code>await collection.find_one()</code> in a loop 10,000 times.

D Use <code>collection.find().limit(10000)</code> without awaiting.

💡 Hint

Think about memory usage when loading many documents.

Option A uses an async iterator to process documents one at a time, which is memory efficient. Option A loads all documents into memory at once, which can cause high memory usage. Option A is inefficient because it makes 10,000 separate queries. Option A does not await the cursor, so it does not fetch data properly.

🔧 Debug

advanced

Debug missing await in Motor query

What error will occur if you forget to use await when calling collection.find_one() in an async FastAPI route?

FastAPI

result = collection.find_one({"_id": id})

A SyntaxError: missing await keyword

B TypeError: object coroutine can't be used directly

C RuntimeError: event loop is closed

D No error, result contains the document

💡 Hint

Remember that Motor methods return coroutines that must be awaited.

Without await, collection.find_one() returns a coroutine object, not the actual document. Using it directly causes a TypeError because the coroutine is not awaited.

🧠 Conceptual

expert

Understanding Motor client connection lifecycle

In a FastAPI app using Motor, what is the best practice to manage the MongoDB client connection to avoid creating multiple clients on each request?

A Create a single Motor client instance at app startup and reuse it for all requests.

B Create a Motor client inside a dependency with <code>yield</code> and close it after each request.

C Create a Motor client globally but close it after each request.

D Create a new Motor client inside each route handler function.

💡 Hint

Think about connection overhead and resource management.

Creating a single Motor client at app startup and reusing it avoids overhead of reconnecting and is efficient. Creating a client per request (A) is expensive. Closing the client after each request (B and C) defeats the purpose of connection pooling and adds overhead.