Full Web Apps with FastAPI Transcripts
Chapter: Storing data with SQLAlchemy
Lecture: Which version of SQLAlchemy
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
Before we start writing code. Let's just take a really quick look at some of the differences of the current SQLAlchemy
0:06
and where we're going and you'll see how we're gonna write code now and then in the next chapter, we're gonna write it against the new API in
0:13
just a little bit of detail. Here we are at SQLAlchemy. There's currently a 1.4.0b1 released about two months ago,
0:22
and this is the culmination of about 18 months of work. And the main goal of this is to bring a new API,
0:29
which will be introduced maybe exclusively in SQLAlchemy 2.0. So when we get to 2.0, we'll have to switch to this new API.
0:37
Let's just really quickly look at the announcements here. So it says this is the first beta release of the SQLAlchemy 1.4 series.
0:44
It's the culmination of 18 months of effort to envision and create a modernized, newly modernized and capable
0:50
SQLAlchemy. The first step along the way to SQLAlchemy 2.0, and includes a gradual introduction to the simplified way of working with,
0:58
most importantly, the ORM So if you just look at some of the changes, there's a simple and more consistent way to work with transactions.
1:04
There's this select() construct that gets used now heavily in the ORM where it used to be you would just go create a query
1:13
and I believe the select stuff was more in the "core", if you wanted to do direct queries some caching,
1:18
which sounds amazing. Here's why we're having this conversation, why this is valuable. This is the first version of SQLAlchemy to provide support
1:26
for a asyncio, meaning async and await and direct integration with FastAPI. So that's gonna be super,
1:33
super awesome, that we can use the ORM with async and await to get massively scalable applications all the way down to the database.
1:41
OK, so that's what the goal here is. We're gonna go through and create everything in a familiar way,
1:46
and then we're gonna make just some changes, really only to the queries that we write, it won't be that big of a deal,
1:51
but you know there it is. Let me just show you what some of those differences look like. So if you go back here to the home page, real quick,
1:58
just to give you guys some guidance here, there's this releases. Oh, look, there's migration notes and there's a big,
2:03
long document about it. But if you look, there's another migrating to SQLAlchemy, which is not those migration notes.
2:09
It's a totally different one. You can see the URL appear at the top. Anyway if you, it's really if you look at the scroll bar,
2:16
it's quite a large document. If you go down, now what is that? About 70% of the way down. It talks about the biggest change in SQLAlchemy
2:23
2.0 will be the use of Session.execute(). Instead of using query, you're going to create select statements and then execute them.
2:31
What's nice is down here we have a couple of examples that we could use. So traditionally, you would write something like,
2:36
I want to get all the users, session.query(User).all(), now you write this, you execute a select statement on the user where you get the scalars
2:45
and then you call all(). Down here you wanna do a filter. So give me the users, so session.query(User) where the name equals "some user",
2:54
give me the first one. Now you'd write, you would execute the statement, select user, filter by name, scalar_one(),
3:02
ok? You notice that this one applies to the query, whereas here, your select and your query is one thing and then you execute it against
3:09
the result of the execution. So there's a little bit of difference going on here. So you can just scroll through this and see that these APIs are
3:17
not even close to similar. Maybe there's some parts that are similar, but to me, they feel fairly different. Like all() is now scalars().all().
3:26
When you do a join, you have to do a unique() on it. So there's just a lot of stuff that is really not directly transferrable. You know,
3:32
it's not necessarily obvious that that's the adjusted thing. So what we're gonna do is we're gonna create this, this version that I believe most people
3:39
who work with the ORM of SQLAlchemy totally have down pat. And then we're going to rewrite the queries in this, not the classes, just the queries,
3:47
and make those asynchronous which is gonna be so worth it. And we're gonna do that in these two chapters.
3:52
Here's the documents that you might wanna look at. So we've got, you know, https://docs.sqlalchemy.org/en/14/changelog/migration_20.html.
4:01
All right, and there you can find this comparison doc. It's about time to write some code, don't you think?