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