MongoDB integration with Motor in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an async MongoDB client using Motor.

FastAPI

from motor.motor_asyncio import AsyncIOMotorClient

client = AsyncIOMotorClient([1])
db = client.test_database

Drag options to blanks, or click blank then click option'

A'http://localhost:27017'

B'mongodb://localhost:27017'

C'ftp://localhost:27017'

D'localhost:27017'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'http://' or 'ftp://' instead of 'mongodb://'.

Omitting the protocol prefix.

The connection string for MongoDB must start with mongodb://. This tells Motor to connect to a MongoDB server.

2fill in blank

medium

Complete the FastAPI endpoint to insert a document into MongoDB asynchronously.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.post('/add')
async def add_item(item: dict):
    result = await db.items.[1](item)
    return {'inserted_id': str(result.inserted_id)}

Drag options to blanks, or click blank then click option'

Ainsert_one

Bfind_one

Cdelete_one

Dupdate_one

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'find_one' which only retrieves data.

Using 'delete_one' or 'update_one' which modify or remove data.

To add a new document, use insert_one which inserts a single document asynchronously.

3fill in blank

hard

Fix the error in the async function to find one document by name.

FastAPI

async def get_item(name: str):
    document = await db.items.find_one({{'name': [1])
    return document

Drag options to blanks, or click blank then click option'

Astr(name)

B'name'

Cname()

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Putting quotes around the variable name, making it a string literal.

Calling the variable as a function.

The value for the 'name' key should be the variable name without quotes, so it uses the function argument.

4fill in blank

hard

Fill both blanks to update a document's field asynchronously.

FastAPI

async def update_item(name: str, new_value: str):
    result = await db.items.update_one(
        {{'name': [1],
        {{'$set': {{'field': [2]
    )
    return result.modified_count

Drag options to blanks, or click blank then click option'

Aname

Bnew_value

C'new_value'

D'name'

Attempts:

3 left

💡 Hint

Common Mistakes

Using string literals instead of variables.

Mixing up which variable goes where.

Use the variable name to find the document and new_value to set the new field value.

5fill in blank

hard

Fill all three blanks to delete a document by id asynchronously.

FastAPI

from bson import ObjectId

async def delete_item(item_id: str):
    result = await db.items.delete_one({{'_id': [1]([2])}})
    return result.deleted_count

# Call example: await delete_item([3])

Drag options to blanks, or click blank then click option'

AObjectId

Bitem_id

C'some_id_string'

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the id as a plain string without ObjectId conversion.

Using wrong variable names in the call example.

Use ObjectId to convert the string item_id to an ObjectId for the query. The call example uses the variable item_id.

Practice

1. What is the main benefit of using Motor with FastAPI for MongoDB operations?

easy

A. It automatically converts ObjectId to string.

B. It provides a graphical interface for MongoDB.

C. It allows asynchronous, non-blocking database calls.

D. It replaces the need for FastAPI routing.

Solution

1. Step 1: Understand Motor's role in FastAPI

   Motor is an async driver for MongoDB, enabling non-blocking calls in FastAPI apps.

2. Step 2: Identify the main benefit

   Non-blocking calls keep the app responsive and fast by not waiting for DB operations.

3. Final Answer:

   It allows asynchronous, non-blocking database calls. -> Option C

4. Quick Check:

   Motor = async, non-blocking calls [OK]

Hint: Motor means async MongoDB calls in FastAPI [OK]

Common Mistakes:

• Thinking Motor provides UI tools
• Assuming Motor auto-converts ObjectId
• Confusing Motor with FastAPI routing

2. Which of the following is the correct way to define a Motor client in FastAPI?

easy

A. client = motor.motor_asyncio.AsyncIOMotorClient('mongodb://localhost:27017')

B. client = MotorClient('mongodb://localhost:27017')

C. client = AsyncMongoClient('localhost:27017')

D. client = motor.MongoClient('mongodb://localhost:27017')

Solution

1. Step 1: Recall Motor client syntax

   The Motor async client is created using motor.motor_asyncio.AsyncIOMotorClient with the MongoDB URI.

2. Step 2: Check each option

   Only client = motor.motor_asyncio.AsyncIOMotorClient('mongodb://localhost:27017') uses the correct class and URI format for Motor.

3. Final Answer:

   client = motor.motor_asyncio.AsyncIOMotorClient('mongodb://localhost:27017') -> Option A

4. Quick Check:

   Motor client = AsyncIOMotorClient [OK]

Hint: Use AsyncIOMotorClient from motor.motor_asyncio [OK]

Common Mistakes:

• Using MotorClient instead of AsyncIOMotorClient
• Omitting 'motor.motor_asyncio' prefix
• Using synchronous MongoClient

3. Given this FastAPI async function using Motor, what will be the output?

async def get_user(db, user_id):
    user = await db.users.find_one({"_id": user_id})
    return str(user["_id"])

medium

A. Returns None if user_id is not found.

B. Returns the string representation of the user's ObjectId.

C. Raises a TypeError because ObjectId can't be converted to string.

D. Returns the user document as a dictionary.

Solution

1. Step 1: Analyze the async function

   The function awaits a find_one query by _id and then converts the _id field to string.

2. Step 2: Understand the output

   It returns the string form of the ObjectId, not the whole document or None.

3. Final Answer:

   Returns the string representation of the user's ObjectId. -> Option B

4. Quick Check:

   str(ObjectId) = string id [OK]

Hint: str() converts ObjectId to string safely [OK]

Common Mistakes:

• Expecting full user dict as output
• Thinking ObjectId can't be stringified
• Assuming None is returned if not found

4. Identify the error in this Motor usage inside FastAPI:

async def fetch_items(db):
    items = db.items.find()
    return await items.to_list(length=100)

medium

A. Missing await before db.items.find() call.

B. to_list() should not be awaited.

C. find() returns a cursor and must be awaited before to_list().

D. No error; code is correct.

Solution

1. Step 1: Understand Motor's find() behavior

   Motor's find() returns an async cursor immediately; no await needed here.

2. Step 2: Check to_list() usage

   to_list() is a coroutine and must be awaited to get the list of documents.

3. Final Answer:

   No error; code is correct. -> Option D

4. Quick Check:

   find() no await, to_list() await [OK]

Hint: Await to_list(), not find() [OK]

Common Mistakes:

• Awaiting find() call incorrectly
• Not awaiting to_list() causing runtime error
• Confusing synchronous and async cursor methods

5. You want to return a list of users from MongoDB in FastAPI, but each user's _id must be a string, not ObjectId. Which code snippet correctly does this?

hard

A. users = await db.users.find().to_list(100)
return [{**u, '_id': str(u['_id'])} for u in users]

B. users = await db.users.find().to_list(100)
return [u for u in users if str(u['_id'])]

C. users = await db.users.find().to_list(100)
return [str(u) for u in users]

D. users = await db.users.find().to_list(100)
return [u['_id'] for u in users]

Solution

1. Step 1: Fetch users as list of dicts

   await db.users.find().to_list(100) returns list of user dicts with ObjectId _id fields.

2. Step 2: Convert each user's _id to string

   Use list comprehension to copy each dict and replace _id with str(u['_id']).

3. Final Answer:

   users = await db.users.find().to_list(100) return [{**u, '_id': str(u['_id'])} for u in users] -> Option A

4. Quick Check:

   Convert ObjectId to string per user [OK]

Hint: Use dict unpacking and str() on _id in list comprehension [OK]

Common Mistakes:

• Returning ObjectId directly without conversion
• Trying to convert whole user dict to string
• Filtering users instead of converting _id