MongoDB for Developers with Python Transcripts
Chapter: Course conclusion
Lecture: Lightning review: mongoengine
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
After we talked about document design and we talked about the raw access from PyMongo we said let's take this up a level of abstraction,
0:09
let's actually build classes and map those over ORM style into MongoDB. We saw a really nice way to do that is with the ODM called MongoEngine.
0:20
Let's review the main way that we sort of define classes and add constraints and things like that.
0:26
Over here we are going to create this car object, this is our dealership example and we are going to store the car in the database.
0:34
The way we create something that MongoEngine can manage in MongoDB as a top level document, is that we're going to derive from mongoengine.document.
0:44
And then every field is going to be one of these fundamental field types, like StringField, IntField, FloatField and so on.
0:51
And we can have some of them required, the first three required, we can have some of them with basic default values, like mileage defaults to zero
1:00
but we can also have interesting functions, for example the vin number is automatically generated
1:05
and we're based in this on the uuid4 random alphanumeric thing, so what we have here so far is really sort of equivalent
1:12
to what you might have in a traditional relational database, there's entry and there is a flat set of what you would call columns,
1:20
this is only part of the story, remember we can have nested documents, we can have actually a rich hierarchy of nested objects.
1:28
One thing we might want to store in the car is an engine and the engine itself is a special type,
1:34
here in the field it's going to be an embedded document field an engine derives from mongoengine.EmbeddedDocument, not document, embedded document.
1:43
These we're never going to directly insert into the database, in fact, we're going to always put them into a car,
1:49
so this is like a strong relationship between a car and its engine, we can even mark it as required. Now going a little further than that,
1:56
our service history actually contains a list of subdocuments, each one modeled by the service record.
2:01
The service record has things like the customer satisfaction, what service was performed and so on.
2:07
Now if we take this, put some appropriate data into it and store it, we'll get something looking along the lines of this,
2:13
in our document database in MongoDB, so here we have the first few elements that are just the flat fields
2:19
and then we have the nested engine, one of them, we have the nested array of nested items for the service histories,
2:25
and this really gets at the power of MongoDB, this nesting and these strong relationships where you get this aggregate object the car,
2:35
that always contains everything we need to know about it. How about queering— we're not going to write now in the low level api,
2:43
we're going to use basically the properties of these objects. Here's the function that we wrote where we wanted to ask the question
2:50
what percentage of cars have bad customer rating, that would be average or below, so we're going to go to the car and we say objects,
2:59
we could do lots of these objects.filter.filter.filter but if you just have one query you can just stick it in object,
3:05
so as the objects service_history, now we can't say dot here, because service_history . customer_rating
3:11
would not be a valid variable name or parameter name in Python, so we're going to traverse a hierarchy with a double underscore.
3:18
We also might want to apply one of the operators, in this case we're going to say less than 4, so we're going to use again this double underscore,
3:25
but in this case it's going to say on the left is the name of the target and on the right is the operator we're going to apply to it.
3:32
You don't put the dollar again, that wouldn't be valid in Python, but double underscore __lt, and then we can ask
3:39
things like count, or go and get the first one, or things like that. We can even do paging by slicing on that result.
3:46
This syntax lets us use almost the entire spectrum of the way of creating MongoDB
3:51
really straightforward and in a way that ties back to the car object that we defined.