Async database with databases library in FastAPI - Step-by-Step Execution

Concept Flow - Async database with databases library

Start FastAPI app

↓

Create Database instance

↓

Connect to DB asynchronously

↓

Handle API request

↓

Run async DB query

↓

Return query result

↓

Disconnect from DB on shutdown

This flow shows how FastAPI app uses the databases library to connect asynchronously to a database, run queries on requests, and disconnect cleanly.

Execution Sample

FastAPI

from fastapi import FastAPI
import databases

app = FastAPI()
database = databases.Database("sqlite:///test.db")

@app.on_event("startup")
async def startup():
    await database.connect()

This code creates a FastAPI app and connects asynchronously to a SQLite database on startup.

Execution Table

Step	Action	Async Operation	State Before	State After	Output/Result
1	Create FastAPI app	No	No app	app instance created	App ready
2	Create Database instance	No	No database object	database object created	DB connection string set
3	Startup event triggered	Yes	database disconnected	database connected	DB connection established
4	API request received	No	database connected	database connected	Request processing starts
5	Run async query	Yes	database connected	database connected	Query result fetched
6	Return response	No	database connected	database connected	Response sent to client
7	Shutdown event triggered	Yes	database connected	database disconnected	DB connection closed
8	App stopped	No	database disconnected	No app running	App shutdown complete

💡 App stops after shutdown event closes the database connection.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 7	Final
app	None	FastAPI instance	FastAPI instance	FastAPI instance	FastAPI instance	None (app stopped)
database	None	Database instance (disconnected)	Database connected	Database connected	Database disconnected	None (closed)
query_result	None	None	None	Data from DB	Data from DB	None

Key Moments - 3 Insights

Why do we use 'await' before database.connect()?

Because database.connect() is an async operation that takes time, 'await' pauses execution until connection completes, as shown in step 3 of the execution_table.

What happens if we try to query the database before connecting?

The query will fail because the database is not connected yet. Step 3 ensures connection before queries run in step 5.

Why disconnect the database on shutdown?

To free resources and avoid connection leaks. Step 7 shows the async disconnect operation during app shutdown.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'database' after step 3?

A Disconnected

B Connected

C Not created

D Closed

💡 Hint

Check the 'State After' column for step 3 in the execution_table.

At which step does the app send the query result back to the client?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look for 'Return response' and 'Response sent to client' in the execution_table.

If we omit 'await' before database.connect(), what will happen?

A The app will raise an error or not wait for connection

B The database disconnects immediately

C The connection will still work synchronously

D The query runs before connection

💡 Hint

Recall that step 3 uses 'await' to pause until connection completes.

Concept Snapshot

Async database with databases library in FastAPI:
- Create Database instance with connection string
- Use async def startup() with await database.connect()
- Run async queries with await database.fetch_all() etc.
- Disconnect on shutdown with await database.disconnect()
- Always use 'await' for async DB calls to avoid errors

Full Transcript

This visual execution shows how to use the databases library asynchronously with FastAPI. First, the FastAPI app and a Database instance are created. On startup, the app connects asynchronously to the database using await database.connect(). When an API request comes in, the app runs async queries with await, fetching data without blocking. After sending the response, on shutdown the app disconnects asynchronously to clean up. Variables like 'database' change state from disconnected to connected and back. Key points include always awaiting async calls and connecting before querying. The execution table traces each step from app creation to shutdown, showing state changes and outputs clearly.