What is the best tool or ORM to manage database in Fast API?

[Achilles0509]

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from typing import List

import databases
import sqlalchemy
from fastapi import FastAPI
from pydantic import BaseModel

# SQLAlchemy specific code, as with any other app
DATABASE_URL = "sqlite:///./test.db"
# DATABASE_URL = "postgresql://user:password@postgresserver/db"

database = databases.Database(DATABASE_URL)

metadata = sqlalchemy.MetaData()

notes = sqlalchemy.Table(
    "notes",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("text", sqlalchemy.String),
    sqlalchemy.Column("completed", sqlalchemy.Boolean),
)


engine = sqlalchemy.create_engine(
    DATABASE_URL, connect_args={"check_same_thread": False}
)
metadata.create_all(engine)


class NoteIn(BaseModel):
    text: str
    completed: bool


class Note(BaseModel):
    id: int
    text: str
    completed: bool


app = FastAPI()


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


@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()


@app.get("/notes/", response_model=List[Note])
async def read_notes():
    query = notes.select()
    return await database.fetch_all(query)


@app.post("/notes/", response_model=Note)
async def create_note(note: NoteIn):
    query = notes.insert().values(text=note.text, completed=note.completed)
    last_record_id = await database.execute(query)
    return {**note.dict(), "id": last_record_id}

Description

I read FastAPI documentation, but still not clear which tools should use to manage database in FastAPI projects.
encode/databases + SqlAlchemy or tortoise-orm?

Operating System

Linux, Windows

Operating System Details

No response

FastAPI Version

0.75.0

Python Version

3.7 +

Additional Context

No response

[yinziyan1206]

I use SqlModel and SqlAlchemy Core. I think it better to use the official ORM tool for FastAPI :)

[Achilles0509]

Yes, I think so.
But I don't think FastAPI has official ORM.
It's developed as micro web framework not full like Django or Laravel.

[yinziyan1206]

eh tiangolo created SqlModel. It combines pydantic model and sqlalchemy and it's comvenient. If you want performance just use tortoise-orm.

[Kludex]

Using the async Core SQLAlchemy performs better than TortoiseORM. You can run the benchmark yourself here.

[Priyansh2]

@Kludex which is the best library for async database connection which supports connection pooling. @tiangolo mention databases in the fastapi docs. Is it better or there is some other available ?

[Kludex]

I use SQLAlchemy.

[Priyansh2]

@Kludex I tried databases using aiomysql driver and sent over 50k concurrent API requests using asyncio and aiohttp. My API reads MySQL database and performs some operations of complexity O(1). At some point, it throws connection refused to 127.0.0.1 error. After that, it failed again when I ran the program and sent 20K requests. I believe there were some hanging connections. I thought databases had garbage collection, but it doesn't. Finally, deciding to go with the async session module of sqlalchemy as it didn't fail by sending the same number of concurrent requests repeatedly. Even there, I found out I can't configure the pool via pool_size, pool_recycle, etc, as it throws the error. Anyway, thanks for your time.

[Achilles0509]

OK, I will check more about it.

My concern is tortoise-orm is growing faster than SqlAlchemy.
I think ranking, star etc are very important.
FastAPI is great framework, so it is growing faster than Django or Flask.
There will be reason why tortoise-orm is growing faster.

[yinziyan1206]

Using the async Core SQLAlchemy performs better than TortoiseORM. You can run the benchmark yourself here.

that's awesome

[Achilles0509]

I made benchmark test on my PC.
But async SqlAlchemy Core is slower than sync SqlAlchemy Core and of course slower than Tortoise ORM

You can see result here

[Leon0824]

Try Prisma.

Define your schema in its Prisma language, and use its generator to generate whole pydantic / db hybrid models. Then import the models module into your project.

[Filsommer]

I've read the prisma-python documentation and it is still not clear how to programatically convert a prisma model (e.g.)

model Item {
  id String    @id @default(cuid()) @db.VarChar(255)
  name String
  price Int
  created_at DateTime?
}

to a pydantic model, like:

class Item(BaseModel):
    id: str
    name: str
    price: int
    created_at: Optional[datetime.datetime] = datetime.datetime.now()

How can this be achieved?

[anthonycepeda]

Try SQLModel. It’s Pydantic + SQLAlchemy.

Here's an example

[Kludex]

@tiangolo would say to check SQLModel.

But for the sake of answering the question... There's no "best tool or ORM to manage database in FastAPI". FastAPI works well with any tool, since it's not coupled with any.

[lozzo]

DONT USE tortoise-orm !!! IT'S ORM BUILT ON BUGS

[enchance]

DONT USE tortoise-orm !!! IT'S ORM BUILT ON BUGS

I don't think it's that bad in fact I much prefer the syntax of Tortoise-ORM. But I stopped using it because its migrations tool Aerich is absolute garbage. The bugs Aerich causes (consistently) offset the usability of Tortoise which sad. I see myself using it again once Aerich realizes it's not all right in the head.

[sinisaos]

Piccolo ORM is an easy-to-use (both async and sync) ORM and query builder that works great with FastAPI. It has automatic migrations (they work pretty well and for some egde cases it's easy to use raw sql in migrations), authentication, admin interface, useful middleware etc. Pydantic can be used in two ways: to write the models ourselves or we can use the create_pydantic_model utility function to convert a Piccolo table into a Pydantic model. I've done some benchmarks for various async ORMs, query builders and drivers. In these tests I focus on read data (I didn't test inserts, updates and deletes) which I think is the main bottleneck in using ORM. That benchmarks (inspired by Tortoise ORM benchmarks) use a FastAPI web app with various ORMs because I think ORMs are mostly used in web applications. I don't know if these benchmarks are good enough, but tests show that Piccolo has better performance than other ORMs in my case.

[fmelihh]

Alembic and async sqlalchemy could be a good choice. I haven't seen tools like Tortoise ORM support less commonly used databases very well. For example, in the company I'm currently working at, we use SQLAlchemy as the core and support it with additional extensions like clickhouse sqlalchemy. When choosing a package, it will be more appropriate to also determine the database you're going to use.