Why databases persist data in FastAPI - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do databases persist data?

Which of the following best explains why databases persist data?

A To delete old data automatically after the application closes

B To keep data available even after the application or server stops running

C To speed up the application by storing data only in memory temporarily

D To prevent users from accessing data during server downtime

💡 Hint

Think about what happens to data when the computer or app is turned off.

Databases save data permanently so it is not lost when the app or server stops. This is called persistence.

❓ component_behavior

intermediate

What happens to data stored in a database after server restart?

Consider a FastAPI app connected to a database. What happens to the data stored in the database if the server restarts?

A The data becomes inaccessible until manually restored

B The data is erased and lost after the restart

C The data is moved to a temporary cache and then deleted

D The data remains intact and accessible after the restart

💡 Hint

Think about the purpose of persistent storage.

Databases store data on disk or other permanent storage, so data stays safe even if the server restarts.

📝 Syntax

advanced

Identify the correct FastAPI code snippet to save data persistently

Which FastAPI code snippet correctly saves data to a database so it persists?

FastAPI

from fastapi import FastAPI
from sqlalchemy.orm import Session
from models import Item

app = FastAPI()

@app.post('/items/')
async def create_item(item: Item, db: Session):
    # Save item to database
    ...

A

db.insert(item)
db.save()
return item

B

db.save(item)
return item

C

db.add(item)
db.commit()
return item

D

db.push(item)
db.commit()
return item

💡 Hint

Look for the standard SQLAlchemy methods to add and save data.

In SQLAlchemy, use add() to add an object and commit() to save changes persistently.

❓ state_output

advanced

What is the output after restarting FastAPI app with saved data?

Given a FastAPI app that saves user data to a database, what will be the output of fetching users after restarting the app?

FastAPI

from fastapi import FastAPI
from sqlalchemy.orm import Session
from models import User

app = FastAPI()

@app.get('/users/')
async def read_users(db: Session):
    return db.query(User).all()

A [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]

B []

C None

D Error: database connection lost

💡 Hint

Think about whether data saved before restart is still there.

Since the data is saved persistently in the database, it remains available after app restart.

🔧 Debug

expert

Why does this FastAPI app lose data after restart?

Review this FastAPI code snippet. Why does the data disappear after restarting the app?

FastAPI

from fastapi import FastAPI

app = FastAPI()

items = []

@app.post('/items/')
async def add_item(name: str):
    items.append(name)
    return {'items': items}

A Because data is stored only in a list in memory, not in a database

B Because the list is cleared automatically on each request

C Because FastAPI deletes variables after each function call

D Because the app uses an incorrect HTTP method

💡 Hint

Think about where the data is saved and what happens when the app restarts.

Data stored in a Python list exists only while the app runs. Restarting clears memory, so data is lost.