Database session management in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a FastAPI endpoint uses a database session dependency incorrectly?

Consider a FastAPI endpoint that uses a database session dependency but forgets to close the session after use. What is the likely outcome?

FastAPI

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session

app = FastAPI()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        pass  # missing db.close()

@app.get("/items/")
def read_items(db: Session = Depends(get_db)):
    return db.query(Item).all()

A The database session will automatically close without any issues.

B The endpoint will raise a SyntaxError due to missing db.close() call.

C Database connections will remain open, potentially causing connection pool exhaustion.

D The endpoint will return an empty list regardless of database content.

💡 Hint

Think about what happens if you open a resource but never close it.

If the database session is not closed, connections stay open and can exhaust the connection pool, leading to errors in subsequent requests.

📝 Syntax

intermediate

Which code snippet correctly manages a SQLAlchemy session in FastAPI?

Choose the code snippet that correctly creates and closes a SQLAlchemy session using FastAPI dependency injection.

A

def get_db():
    db = SessionLocal()
    yield db
    # no close call

B

def get_db():
    db = SessionLocal()
    yield db
    db.close()

C

def get_db():
    db = SessionLocal()
    try:
        yield db
    except:
        db.close()

D

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

💡 Hint

Consider how to guarantee cleanup even if an error occurs.

Using try-finally ensures db.close() runs no matter what happens during yield.

❓ state_output

advanced

What is the state of the database session after the endpoint finishes execution?

Given this FastAPI dependency for database session management, what is the state of the session after the endpoint returns?

FastAPI

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/")
def read_users(db: Session = Depends(get_db)):
    users = db.query(User).all()
    return users

A The session is closed and all resources are released.

B The session remains open and can be reused by other requests.

C The session is rolled back but not closed.

D The session is committed but not closed.

💡 Hint

Look at what happens in the finally block.

The finally block calls db.close(), so the session is closed and resources freed after the endpoint finishes.

🔧 Debug

advanced

Why does this FastAPI app raise 'InvalidRequestError: Session is closed'?

Examine the code below. Why does the app raise 'InvalidRequestError: Session is closed' when trying to query the database?

FastAPI

def get_db():
    db = SessionLocal()
    try:
        db.close()
        yield db
    except Exception:
        db.rollback()

@app.get("/products/")
def read_products(db: Session = Depends(get_db)):
    products = db.query(Product).all()
    return products

A db.rollback() is called without an active transaction, causing the error.

B db.close() is called before the endpoint finishes, closing the session too early.

C The session is never closed, causing resource leaks.

D The dependency function is missing a yield statement.

💡 Hint

Check the order of yield and db.close() calls.

db.close() is called before the yield, so the session closes before the endpoint uses it, causing the error.

🧠 Conceptual

expert

Why use dependency injection for database sessions in FastAPI?

What is the main advantage of using dependency injection to manage database sessions in FastAPI applications?

A It ensures each request gets a fresh session that is properly closed, preventing connection leaks.

B It allows sessions to be shared globally across all requests for performance.

C It automatically commits all transactions without explicit calls.

D It removes the need to import SQLAlchemy in endpoint code.

💡 Hint

Think about resource management and request isolation.

Dependency injection provides a new session per request and ensures it closes properly, avoiding leaks and conflicts.