Building data-driven web apps with Pyramid and SQLAlchemy Transcripts
Chapter: MongoDB edition
Lecture: MongoDB entities

Login or purchase this course to watch this video and the rest of the course contents.
0:00 With our connection all set up and in place
0:02 it's time to start creating our models.
0:04 Remember, over here, we had like a Package and the User.
0:08 The User was pretty simple, we can go with that.
0:10 So, we created a class
0:11 it derived from a certain base class
0:13 we gave it a little meta information
0:15 and we declared the columns, their types
0:17 and their behaviors, whether they're primary keys and so on.
0:20 We'll do exactly the same thing for MongoEngine.
0:23 That looks like it's going a little crazy
0:25 let me just restart PyCharm so it gets its cache
0:28 for auto-complete corrected.
0:32 Ah, better, looks like it now knows about everything.
0:35 Every now and then PyCharm goes a little wonky
0:38 and loses some stuff there. So it's good.
0:42 Now let's go create the equivalent
0:44 of this User class over an our nosql.
0:49 Call it users, we're going to keep exactly the same file names
0:51 that'll help us a little bit in conversions
0:54 and then we're going to import mongoengine
0:56 just like we imported SQLAlchemy.
0:59 We're going to create a class, called User
1:01 and it's going to drive from mongoengine.Document.
1:04 We're don't have tables, we have a records
1:05 we have documents in MongoDB.
1:07 It has an implicit id, which is going to be fine
1:12 for the primary key and it'll auto-generate that for us.
1:15 We don't have to say that like we do over here.
1:18 Put these other things, let's put them across.
1:21 So we want to name
1:22 and SQLAlchemy obviously is not what we want.
1:26 We're going to use mongoengine
1:27 and this time we're going to have a StringField
1:30 and we could say required equals False
1:34 to match this nullable is True
1:37 but unless we say required is True
1:39 it's going to be effectively nullable by default.
1:41 So the top one and these two lines, four and five, same
1:46 and we'll do the same for email.
1:50 Nullable, now notice this index down here
1:53 we don't put the index here, we put it somewhere else
1:54 so I'm going to just put a little comment here.
1:56 Index, nullable, let's just keep going.
1:58 This is real similar, it's a string. Just like that.
2:05 This is a datetime, we know what that looks like.
2:09 We have a DateTimeField, and guess what
2:11 we have default values, just the same.
2:16 So hopefully this feels super comfortable to you
2:18 because you know it's really very, very little difference.
2:22 Again, a StringField, actually we never use this.
2:24 Let's just drop that one and same for this.
2:26 Let's just go with this.
2:28 So final thing to tie these together.
2:32 Over here we controlled stuff
2:34 by saying we want this to be in the users table like this.
2:37 On this version we do it a little bit different.
2:38 We have a meta dictionary in here
2:41 and it's not really obvious
2:42 but we're going to set some keys.
2:43 We're going to say db_alias
2:44 that's the alias we set before
2:46 and it was core, remember, this is the one?
2:48 You can have multiple connections to different databases
2:50 and say these entities go here or there.
2:53 This is how you do it SQLAlchemy
2:54 you would have different base classes
2:56 whereas on this one
2:58 you have different connection aliases.
3:01 Then the table name is now Collection
3:03 'cause we don't have tables we have collections.
3:04 And this is going to be users.
3:06 And then remember the index is up here.
3:08 We had email and hashed_password.
3:13 Want to set that to an array of just the names
3:16 email, hashed_password.
3:18 Maybe we also want one for created date, just to be safe.
3:21 We want to find the newest users or something like that.
3:24 There we go then we can get rid of these bits here.
3:26 Done, that's it!
3:27 Let's see really quickly how we just use this.
3:30 I'm just going to throw this into the most wrong place
3:33 there possibly is, right in the init_db.
3:36 Well let's suppose we wanted to create a new user
3:38 and first of all
3:39 I'm going to connect to this thing called Robo 3T.
3:41 I already have MongoDB running
3:42 and Google how to do that for your OS on how to set that up
3:46 or go check out the other courses.
3:52 So you notice we have this PyPI Demo full thing
3:54 that I already made.
3:55 This one actually has more data.
3:57 We can play with it later
3:58 but notice around here there's no pypi_nosql.
4:02 Database doesn't exist yet, right?
4:04 So, when we begin to talk to it the first time
4:08 MongoEngine will create the database
4:10 and configure the tables with the indexes
4:12 and names, and things like that.
4:13 So let's say that's just really quick.
4:25 So here we've created a new user.
4:27 Now rememeber in SQLAlchemy
4:28 we have what's caled the unit of work pattern.
4:32 MongoEngine is more like Django style
4:34 in that it follows what's called active record.
4:36 In that pattern, we work in individual documents more.
4:39 So we'll juts come over here and go user.save()
4:42 and that'll insert it into the database.
4:43 So by starting the website
4:45 it's going to run this code which is going to talk to MongoDB
4:48 create the database, create the tables
4:49 and insert it all in one shot.
4:51 Let's go.
4:55 Great, we registered our development connection
4:58 and it didn't crash so that probably worked.
4:59 Let's see.
5:00 Right, go in refresh.
5:02 There's our nosql.
5:03 Here's our one collection.
5:04 Here's our indexes.
5:05 And let's go find our user.
5:08 There, not super interesting
5:10 nothing embedded or anything like that
5:12 it's just a stardard record but there it is in the database.
5:15 You can see the ID is automatically created.
5:18 The defaulte value is set on the created date
5:19 and then these are the two I entered.
5:21 Super easy to work with, right?
5:23 There's not a whole lot of value
5:24 for you seeing me to do that for each one of these
5:27 so let me just drop in all of these entities
5:31 because they're all the same.
5:32 We'll talk through anything that's interesting, okay?
5:37 Okay, so now you can see we've got them all.
5:39 We've got our mongo_setup we added
5:40 that didn't change.
5:42 Our users, pretty much the same thing.
5:45 Here's our releases, it's all good.
5:48 So you can see these are all pretty standard.
5:50 The one that gets kinda intereseting
5:52 and let's go look at packages real quick.
5:54 So over here this stuff is all sort of columner
5:57 you know, standard real column type stuff
6:00 but this one, check this out.
6:01 This is a list field.
6:02 So this is that embedded relationship of maintainers.
6:06 In SQLAlchemy we have packages, we have users
6:09 and we have another table called maintainers
6:11 that is mapping the many-to-many relationship between them.
6:14 This one line right there avoids that other table
6:18 avoids those joins
6:20 and does that many-to-many mapping perfectly.
6:23 And of course we'll want to have some kind of index on this.
6:27 So maybe maintainers just like that.
6:29 Alright, so let's run this again.
6:32 So it looks like it's working, right?
6:33 Man, now let's see how much we've got going on over here.
6:36 Did this fill up all the tables?
6:37 Now we haven't interacted with the others
6:39 so nothing's happening yet.
6:40 If we click it, not so much.
6:43 None type is not callable.
6:45 You know what that is?
6:47 That is us trying to work
6:48 with our session factory in SQLAlchemy.
6:52 So our next step is going to be going
6:54 let's show you where this is.
6:56 This is in our package service.
6:58 Our next step is going to be to take these data
7:01 these new entities that we've created
7:02 and rewrite our data access layers.
7:04 Maybe that sounds not very fun.
7:06 It turns out it's almost no work.
7:08 It's amazing. So we're going to do that
7:09 and then we'll pretty much have our app running.
7:12 It'll have no data, but it'll be up and running.