|
|
00:00 We saw querying in MongoEngine was really quite straightforward
|
|
|
00:04 and mostly was done by way of interacting with the class
|
|
|
00:07 and the arguments, not breaking down and working
|
|
|
00:12 in the actual MongoDB or even PyMongo api;
|
|
|
00:15 so let's look at a couple of options,
|
|
|
00:17 a couple of ways in which we might do some queries.
|
|
|
00:19 So here we have a function called find_car_by_id
|
|
|
00:21 and notice it's taking a car id which we're using type annotations or type ins
|
|
|
00:25 to indicate that this is an object id that comes in
|
|
|
00:28 and what we give back, what we're returning is an individual single car
|
|
|
00:31 and really for the type ins to be entirely correct
|
|
|
00:34 you should say optional car, because it may be none as we saw.
|
|
|
00:37 So we are going to say car.objects and then filter(id = car_id)
|
|
|
00:41 so what we're doing is saying we're looking for the car object
|
|
|
00:44 that has id = car_id, now this is by primary key basically
|
|
|
00:48 so you expect it's one or zero, we do a first
|
|
|
00:51 so that actually returns either the object or none.
|
|
|
00:54 One thing to know is in the database it's _id and
|
|
|
00:57 in MongoEngine they are like forget the underscore it's just straight up id,
|
|
|
01:01 so minor difference there,
|
|
|
01:03 we also saw that if you have just one filter, like a really simple thing
|
|
|
01:06 you could just say objects_id = card_id
|
|
|
01:08 and don't have to do the filter step, but I kind of like this explicit style.
|
|
|
01:11 So we're going to say we're looking for one or more fields
|
|
|
01:16 we're only passing id but we could pass id and vin number and other types of things
|
|
|
01:21 and we call first to get one or nothing at all,
|
|
|
01:26 next, we might want to query by subdocuments
|
|
|
01:29 or things contained in a list inside of that document, stuff like that;
|
|
|
01:33 so we can also do this with MongoEngine.
|
|
|
01:36 Same type of thing card.objects.filter, however what goes in here
|
|
|
01:40 is no longer just the straight name,
|
|
|
01:43 in fact, we're going to use the double underscore
|
|
|
01:45 to traverse that hierarchy, so we're going to go down to service history,
|
|
|
01:50 then within service history we're going to look at customer rating.
|
|
|
01:54 Now, if we're going to return this, we maybe don't want to return it active cursor
|
|
|
01:59 we may either want to use a generator
|
|
|
02:02 or here what we're doing is we're actually creating a list
|
|
|
02:04 we're saying list of cars, that way by the time this function is done executing
|
|
|
02:09 it actually is going to entirely have finished whatever it's doing with the database
|
|
|
02:14 and you'll basically be done with the database by the time you leave this function.
|
|
|
02:19 Notice we're also using type ins to say this takes a list of cars,
|
|
|
02:22 this time we didn't call first we're just converting all of the responses to that list.
|
|
|
02:27 All right, finally this one that we just looked at
|
|
|
02:31 was looking exactly at the customer rating of 4,
|
|
|
02:34 but here we want to know like show me all the cars
|
|
|
02:37 that were not rated with great service, right
|
|
|
02:39 that is 3, 2, 1 or 0, if that's a possibility,
|
|
|
02:43 and in fact, we're going to use not pull all the cars back
|
|
|
02:47 but we want to know like as a percentage how are we doing,
|
|
|
02:50 how many cars that we have that had sub amazing service, versus all of them
|
|
|
02:55 so we're using the count operator here,
|
|
|
02:57 we can get all the cars by saying card.objects.count
|
|
|
03:00 or we can run our query and say count and get just the ones that match the query.
|
|
|
03:03 So in this case, we're going to say you the double underscore yet again
|
|
|
03:07 this time to use the less than operator,
|
|
|
03:09 so what we're saying in this case is the bad cars how many are there,
|
|
|
03:13 well, we're going to go to service history.customer rating
|
|
|
03:16 and show me all the ones that are less than 4
|
|
|
03:18 and count how many of those occur.
|
|
|
03:20 Right, so we'll just use the count operator
|
|
|
03:23 instead of actually returning deserializing the documents
|
|
|
03:25 this is much, much faster than saying give me all the bad cars
|
|
|
03:28 do a lin operator, unless you have a really, really great service. |