Building Data-Driven Web Apps with Flask and SQLAlchemy Transcripts
Chapter: MongoDB edition
Lecture: Rewriting our queries

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Now in this section, we get to see the power of our proper factoring of the various aspects of our application. It's totally possible that people go
0:10 and start writing actual queries right in here, right. Right in the view method. We made a point not to do that. We're using the view models
0:18 to make sure the data exchange is clean and inside those view models, like this one here we're going to our services
0:26 our package service for example on calling Get package by ID where we're passing a name along. So, when we go and change the queries
0:33 we need to rewrite them from using SQLAlchemy to using MongoDB you'll see that really, for the most part we could just change only those three files
0:42 little services, that are dedicated to database queries and nothing else at all. It turns out the base view model, it's cookie management
0:52 is exchanging an integer and we're later going to need to change that to a BSON ObjectID but other than that, we won't have to touch anything.
0:59 So let's go and get started. I guess probably the most important one is to go to this package service one. This is the one that was crashing.
1:06 So let's go down here and look at all packages. Remember, the way it works is SQLAlchemy creates a unit of work, a session
1:12 we do some stuff and then we have to close out that session. It turns out it's way simpler in MongoEngine. So let's get rid of all that stuff.
1:21 And we come over here and we still want to execute this as a list but instead of doing a session query we just go to the package thing
1:29 and we say, dot objects, as long as we import the right one at the top so we're going to change data to nosql
1:37 down here now we can say objects(), like this and it's just going to pull it in and go. This is it! That's the entire query, we also have
1:45 a limit in MongoEngine, just like we do on SQLAlchemy. Up here, again, we want to get a package by ID. This looks kind of complicated
1:53 we've got our validation, that's all fine. This stuff, we don't need any of that this stuff, we don't need any of that
2:01 and remember, the session query just goes to package.objects(), so we don't have joins here so that's good. And then when we do this filter
2:13 we could either do it here, we could actually just put it inside of objects. We don't use the type name in double equals
2:18 we just use the field name and single we just assign the value. So literally, that's it. get_package_by_id just got simpler didn't it.
2:28 Let's keep going. Well it's not going to take long at all to finish this up so we do that business, over here
2:33 convert this release to release.objects, like so call count, done, send them away, just keep going.
2:41 Package count, package.objects().count(), like that. All right, get latest releases what was that, in a second? Yeah this is the last one
2:50 so let's go ahead and write this one we can drop that clean this all up change a release here, one more time
3:00 just say dot objects, like so, don't have joins. We do have order_by, do have limit and we do have all however, again remember, we don't say
3:10 when we're doing a order_by, just like with a quality we don't say the type name. This one I don't like as much I prefer SQLAlchemy's
3:17 but what we're going to do is we're just going to go down here and put as a string, either, like this for ascending
3:26 or a minus, here, for descending for the order by. And that's it! We've completely changed all the package queries
3:35 theoretically, I haven't tested this yet but theoretically work under MongoDB. Let's go quick and do user_service One as well.
3:44 That can go, this one becomes a nosql can one come over here, just change this. It's kind of a little bit annoying
3:55 but I want to go through the entire process of changing everything because it's actually just going to take like five minutes
4:02 to rewrite all the queries. So let's just spend those five minutes so you can see what the whole experience is like.
4:08 And objects in the filter, we just change this to email the field equals email the value done. Look at, not only is this easy
4:16 most of the time it's cleaner an simpler love it. Okay, same thing here, we create the user we set their values but in order
4:24 I hope I don't mess them up. But instead of doing this, all of this stuff here we just go and say,
4:34 remember active record, and we return it. It's going to return with it's primary key set and all that. Okay, all this is looking pretty good here.
4:49 And go login_user now actually down here we have a, find_user_by_email and that's what we're trying to check
4:55 so let's just not do this, let's call this function here and it's going to be smarter. Whoops, we want the email in, that's good.
5:04 And then, last one we need to rewrite this.
5:21 Here we Have it. So I think we've rewritten this one as well. Let's run our site and see how it's working if we're lucky we'll see the home page
5:29 if not, we'll see it crash. TADA! Look at that! And is it working? Well there's no releases, that cause
5:37 we haven't imported any data, there's no projects but check it out, there are two users those are the two users we inserted, so yeah
5:43 it look's like it's actually using our data our queries to go to the database and pull this back. How cool is that?
5:50 Yeah it was a little bit tedious to do this but we completely re-wrote the data access layer from my relational to a non relational document data base
5:59 in a hand full of minutes, it's amazing.

Talk Python's Mastodon Michael Kennedy's Mastodon