Using an ORM with FastAPI

In this blog post, we will discuss the steps to setup and work with an ORM in FastAPI, aiming to create more maintainable and efficient code.

No time to waste, let’s get started 🏃‍♂️

What is an ORM?

An Object-Relational Mapping (ORM) is a programming technique used to manipulate your database, like querying, updating, or deleting data, using an object-oriented paradigm. In Python, there are several libraries for ORM, but for this tutorial, we'll use SQLModel, which plays nicely with FastAPI and allows you to work with SQLAlchemy and Pydantic simultaneously.

Step 1: Installing SQLModel

Before we start, ensure Python 3.6 or later is installed. Then, install FastAPI and SQLModel using pip:

pip install fastapi[all] sqlmodel

Step2: Setting up the Database Model

Let's start by defining a simple model. Models are python classes that define the structure of your database tables and their relationships:

from sqlmodel import SQLModel, Field

class Book(SQLModel, table=True):
    id: int = Field(default=None, primary_key=True)
    title: str
    author: str
    year: int

In this Book model, id, title, author, and year represent the columns of our database table.

Step 3: Creating the Database

Here, we will create a SQLite database for our example:

from sqlmodel import Session, SQLModel, create_engine

sqlite_url = "sqlite:///books.db"
engine = create_engine(sqlite_url)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)

Running create_db_and_tables() will create a new SQLite database with a books table.

Step 4: Interacting with the Database

Now that our database is set up, we can start interacting with it. For instance, to insert data into our database, we can create a new Book instance and add it to our session:

def create_book(book: Book):
    with Session(engine) as session:
        session.add(book)
        session.commit()

Here's how you'd use this function:

new_book = Book(title="1984", author="George Orwell", year=1949)
create_book(new_book)

Fetching data from the database is straightforward as well:

def get_books():
    with Session(engine) as session:
        books = session.exec(Book.select()).all()
        return books

This function retrieves all the books in the database.

Step 5: Integrating with FastAPI

FastAPI integrates well with SQLModel. Let's define some routes for creating and retrieving books:

from fastapi import FastAPI
app = FastAPI()

@app.post("/books/")
async def create_book_endpoint(book: Book):
    create_book(book)
    return {"message": "Book created"}

@app.get("/books/")
async def get_books_endpoint():
    books = get_books()
    return {"books": books}

And that's it! We have a simple FastAPI application that uses SQLModel as an ORM.

Thank you for taking the time to read this! I sincerely hope that your time was well-spent.

https://chat.openai.com/share/69589825-a589-488a-98c0-a462fe797c36