Why databases persist data in FastAPI

Introduction

Databases keep data safe even when the app or computer is turned off. This helps us save and find information anytime.

You want to save user information like names and passwords.

You need to keep track of orders in an online store.

You want to store messages in a chat app so users can see old chats.

You want to save settings or preferences for users.

You want to keep logs or records that last over time.

Syntax

FastAPI

Databases store data on disk or cloud storage so it stays after the program stops running.

Databases use special software to organize and manage data safely.

FastAPI works well with databases to save and get data in web apps.

Examples

This example saves user data only while the app runs. If the app stops, data is lost because it is not saved in a database.

FastAPI

# Example: Saving user data in a database
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

users = []  # This list is temporary and lost when app stops

@app.post('/users/')
async def create_user(user: User):
    users.append(user)
    return user

This example saves user data in a database file. Data stays saved even if the app stops and restarts.

FastAPI

# Example: Using a database to persist data
# (Pseudocode, actual DB setup needed)
from fastapi import FastAPI
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

app = FastAPI()

engine = create_engine('sqlite:///./test.db')
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String)
    age = Column(Integer)

Base.metadata.create_all(bind=engine)

@app.post('/users/')
async def create_user(name: str, age: int):
    db = SessionLocal()
    user = User(name=name, age=age)
    db.add(user)
    db.commit()
    db.refresh(user)
    db.close()
    return user

Sample Program

This FastAPI app saves items only while it runs. If you restart the app, all items disappear because they are not saved in a database. This shows why databases are important to keep data safe and persistent.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str

items = []  # Temporary storage

@app.post('/items/')
async def create_item(item: Item):
    items.append(item)
    return {"message": "Item saved temporarily", "item": item}

@app.get('/items/')
async def read_items():
    return items

Important Notes

Data stored only in memory (like lists) disappears when the app stops.

Databases save data on disk or cloud so it lasts longer.

Using databases helps apps remember user info, settings, and history.

Summary

Databases keep data safe even when apps stop or restart.

Without databases, data is lost when the program ends.

FastAPI can work with databases to save and retrieve data reliably.

Practice

1. Why do databases persist data in applications like FastAPI?

easy

A. To keep data safe even if the app stops or restarts

B. To make the app run faster

C. To delete old data automatically

D. To prevent users from accessing the app

Solution

1. Step 1: Understand what persistence means

   Persistence means data stays saved even after the program stops running.

2. Step 2: Connect persistence to databases in FastAPI

   Databases store data on disk, so FastAPI can retrieve it later, even after restarts.

3. Final Answer:

   To keep data safe even if the app stops or restarts -> Option A

4. Quick Check:

   Persistence means data stays saved [OK]

Hint: Persistence means data stays saved after app stops [OK]

Common Mistakes:

• Thinking databases speed up the app only
• Confusing persistence with data deletion
• Believing databases block user access

2. Which of the following is the correct way to save data to a database in FastAPI?

easy

A. Use a database session to add and commit the data

B. Print the data to the console

C. Store data in a local variable only

D. Use a global variable to hold data

Solution

1. Step 1: Identify how FastAPI interacts with databases

   FastAPI uses database sessions to add and commit data to save it permanently.

2. Step 2: Compare options for saving data

   Printing or using variables does not save data persistently; only committing via session does.

3. Final Answer:

   Use a database session to add and commit the data -> Option A

4. Quick Check:

   Commit data with session to save [OK]

Hint: Commit data with session to save persistently [OK]

Common Mistakes:

• Thinking printing saves data
• Using variables instead of database commit
• Skipping the commit step

3. Given this FastAPI code snippet, what will happen when the app restarts?

from fastapi import FastAPI
from sqlalchemy.orm import Session

app = FastAPI()

@app.post('/items/')
def create_item(session: Session, item: Item):
    session.add(item)
    session.commit()
    return item

medium

A. The items will be saved only in memory

B. The saved items will be lost after restart

C. The app will crash on restart

D. The saved items will still be available after restart

Solution

1. Step 1: Understand what session.commit() does

   Calling commit() saves data permanently to the database storage.

2. Step 2: Consider app restart effect on database data

   Since data is saved in the database, it remains after the app restarts.

3. Final Answer:

   The saved items will still be available after restart -> Option D

4. Quick Check:

   Committed data persists after restart [OK]

Hint: Committed data stays after app restarts [OK]

Common Mistakes:

• Confusing commit with temporary memory storage
• Assuming app restart clears database
• Thinking session.add alone saves data

4. What is wrong with this FastAPI code that tries to save data?

from fastapi import FastAPI

app = FastAPI()

@app.post('/users/')
def create_user(user: dict):
    user['id'] = 1
    return user

medium

A. It uses the wrong HTTP method

B. It does not save data to a database, so data is lost on restart

C. It has a syntax error in the function

D. It commits data twice

Solution

1. Step 1: Check if data is saved to a database

   The code only modifies and returns a dictionary; it does not save to any database.

2. Step 2: Understand consequence of no database saving

   Without saving to a database, data is lost when the app stops or restarts.

3. Final Answer:

   It does not save data to a database, so data is lost on restart -> Option B

4. Quick Check:

   No database save means no persistence [OK]

Hint: Data must be saved to database for persistence [OK]

Common Mistakes:

• Thinking returning dict saves data
• Confusing HTTP method with persistence
• Assuming syntax error when none exists

5. You want to ensure user data is saved permanently in FastAPI. Which approach correctly combines FastAPI and database persistence?

hard

A. Store user data in a global list variable inside the app

B. Save user data only in request body without database interaction

C. Use FastAPI with SQLAlchemy session to add and commit user data to a database

D. Print user data to console and rely on logs for storage

Solution

1. Step 1: Identify how to save data permanently

   Permanent saving requires writing data to a database, not just memory or logs.

2. Step 2: Match FastAPI with database usage

   FastAPI works well with SQLAlchemy sessions to add and commit data to databases.

3. Step 3: Eliminate incorrect options

   Global variables and printing do not persist data after app stops; request body alone is temporary.

4. Final Answer:

   Use FastAPI with SQLAlchemy session to add and commit user data to a database -> Option C

5. Quick Check:

   Database commit ensures permanent data [OK]

Hint: Use database session commit for permanent save [OK]

Common Mistakes:

• Using global variables for persistence
• Relying on request data without saving
• Thinking console logs save data