Full Web Apps with FastAPI Transcripts
Chapter: async databases with SQLAlchemy
Lecture: Updating the db_session for async
0:00 Here we are in chapter eight now. You can see I've copied the code, the final code from chapter seven over as per usual,
0:07 now it's the starter code for chapter eight. In order for us to work with the new version of SQLAlchemy,
0:13 the first thing we gotta do is actually we've gotta go over here and adjust this to say, this is a certain version and funny the way this is coming
0:21 together, we're creating a fake PyPI, we're going to need to go to the real PyPI and find SQLAlchemy,
0:26 go to its releases, and here's the beta version that we want. And we can just copy that bit right there.
0:38 And so what we wanna put over is this. That'll allow us to use the async features that are not in the 1.3 edition. Let that reinstall here. All right,
0:49 that looks like that worked. Now the API is different for working with SQLAlchemy. We don't create just a session and use the query the same,
0:56 what we do is we create an async session. The first thing that we have to make changes to is to our db session
1:02 class because we need to do the async stuff. The other difference in the API here, in the traditional one,
1:08 we created a factory that creates the session. But what we're going to need to actually store and notice if we go down to where we
1:14 put this together, We've got a connection string, we create an engine, the engine is passed the factory,
1:20 and then the factory is used later. In the a async model, what we do is we have to hang on to the engine and then each time,
1:27 use that to create kind of a context block type thing with the engine. So we go over here and we're going to create an __async_engine
1:35 that's just this internal thing, It's gonna be an async engine, which we can import from sqlalchemy.ext.asyncio and
1:44 we'll make that Optional of that because we want to set it to be None in the beginning, and the way that we create it is pretty similar.
1:53 So here we have this create_engine and we're gonna do something like that. But instead of calling this, we're gonna say,
1:59 create_async_engine like so, the parameters that go to it are the same but this set here, this async create is what we need.
2:09 And it's telling us that this needs to be registered as a global for us to make a change instead of just overriding a local.
2:15 Okay, so that's working. And then this create_session thing is gonna use that over here. So we'll say def create_async_session. Let's call it that.
2:24 This is gonna return an AsyncSession like so. We'll say we're gonna use this global __async_engine here.
2:33 And let's just do a quick test, it was like this where we said, you know, you've not set this up before,
2:39 so for some reason, if our __async_engine is not called, then we know that they didn't call the right set up,
2:45 and this is gonna be a big problem for us, perfect. And then this is pretty straightforward.
2:49 We're gonna create the session, which is an a AsyncSession. Instead of just calling the factory,
2:55 we're just going to allocate it and pass the async engine along like this. And from here on, it's pretty similar to what we have before.
3:03 Pretty similar, not the same. Now notice this expire doesn't, expire_on_commit doesn't exist. So this is the async session
3:09 but there's within it a sync session for which we can set the expire_on_commit.
3:14 All right, so that's pretty much the changes that we're going to have to make
3:18 in order to have our async engine stored and then the ability to create these async sessions. We're gonna go and
3:25 use this function instead of this one to go through and do these async queries against
3:30 SQLAlchemy. Let's just run it to make sure when it runs this whole startup code, everything's hanging together. Perfect,
3:36 it looks like it is. So our foundation to create these sessions we need to rewrite the queries is all in place, looks good.