00:01 Let's explore this slightly updated version of our code.
00:04 Here we are in the github repository,
00:07 and I am in the source folder and I've added an 08_perf section,
00:10 and we have the starter_big_dealership and we have the big_dealership
00:15 it even has instructions here to tell you basically how to restore
00:17 that database we did just in the previous video.
00:20 This one is going to be a snapshot of how this chapter starts,
00:24 it's what we're starting from now and will remain that way;
00:27 here we're going to take basically a copy of that one
00:29 and evolve it into the fast high performance version,
00:33 so let's go over here and see what we've got.
00:35 Now, we have a few things that are slightly different,
00:38 the car is basically unchanged from before
00:41 although I added a little comment about how do we get to the owners.
00:45 The one thing that is new here, in terms of the model is this owner idea,
00:50 so cars can now have an owner
00:52 and how do we know which cars are owned by this owner
00:57 is we have a list of object ids, those object ids are the object ids of the cars
01:02 so we're going to push the ids of the cars that are owned here
01:06 I guess we could run it as a many to many or one to many relationship,
01:10 just depending on how we treat the owner, but theoretically,
01:13 we can have owners where there is a single car that is multiple owners
01:17 and there are owners that own multiple cars, and we can manage it this way,
01:21 you almost never see like a car to owner intermediate table,
01:25 so you're almost always going to have something like
01:27 those ids are either embedded in the owner or in the car,
01:32 or under rare circumstances both.
01:35 So here's how we refer back to the cars,
01:38 then we have a few basic things like the name,
01:41 when was this owner created, how many times have they visited and things like that.
01:45 We want to call it owners in the database and it's just this core collection,
01:49 so other than that, there's not a whole lot going on here,
01:51 let's look over here, we now have these services,
01:54 I've taken all the car queries and moved them down here
01:57 do you want to create a car, you call this function,
01:59 do you want to record a customer visit, here we can go to the owner
02:03 and we can use this increment operator
02:06 to increment the number of visits in place.
02:09 Find cars by make, find owner by name and so on.
02:16 Number of cars with bad service, a lot of this stuff is what we wrote previously;
02:20 there was the program thing that we ran over here that was interactive
02:23 and I've replaced that with a few things,
02:25 one is this db stats and you can run this and it will tell you
02:28 like how many cars are there, how many owners are there,
02:31 what's the average number of histories,
02:33 this is basically those stats that I presented to you before,
02:36 this takes a while to run on this database, I don't recommend you run it
02:39 but if you want to just run it and see what you get you can.
02:42 The database was originally created using this script,
02:46 I am using something interesting you may not have heard about,
02:49 I am using this thing called Faker, so down here
02:53 Faker lets you create this thing and I'm seeding it
02:59 so it always generates exactly the same things,
03:01 I'm seeding random and fake and you can see down here
03:04 it's creating the owners and you can ask it for things like
03:06 give me a fake name, give me a fake date
03:08 between these two dates, things like that.
03:12 Similarly with cars, we're using random to get a hold of a lot of the numbers
03:15 then we can use fake for anything else we might.
03:18 We ran this, with the right amount of data, it'll build it all up for us,
03:25 so for some reason if you need to recreate it
03:27 run this low data thing, you can have it create a small one,
03:30 if you comment, uncomment that or a large one
03:32 if you only run it with those settings.
03:34 Those are all good, this is like the foundation and this is where we are.
03:37 Next, we're going to ask interesting questions of this database
03:43 and we want to know how long those questions take to answer,
03:46 so I've written this super simple function called time
03:48 you pass it a message and a function,
03:50 it will time how long the function takes to run
03:53 and then print out the message along with the time in terms of milliseconds.
03:57 And then we're going to go through
03:59 and we're going to ask interesting questions here
04:01 like how many owners, how many cars, who is the 10 thousandth owner,
04:05 notice the slicing here to give us a slice of item of length one
04:10 and then we'll just access it,
04:12 and then we can start asking interesting questions like
04:14 how many cars are owned by the 10 thousandth owner,
04:17 or if we go down here, how many owners own the 10 thousandth car,
04:21 so ask it in the reverse direction.
04:23 Here we want to find the 50 thousand owner by name,
04:26 so yes, technically have them but the idea is
04:30 we want to do a query based on the name field
04:32 and we originally won't have any performance
04:35 around these types of queries so it should be slow.
04:38 This one, how many cars are there with expensive service
04:40 this was the one with the snail
04:43 and in one of the first videos in this chapter,
04:46 I showed you look this takes 700 milliseconds to run to ask this question
04:49 how many cars have a service history with a price greater than 16800.
04:55 So we're going to be to be able to ask all of these questions
04:58 and this program will let us explore that
05:02 and we'll see how to add indexes
05:04 and I'll show you how to add indexes in the shell
05:06 and how to add them in MongoEngine, and MongoEngine is really nice
05:09 because as you evolve your indexes, as you add new ones
05:13 simply deploying your Python web app
05:15 will adapt the database that it goes and finds
05:18 to automatically upgrade to those indexes, so it's really really nice.
05:22 So here you can see we're going to run this code and ask a bunch of questions
05:25 we could load the data from here, we could generate the data,
05:28 but you're much better off importing the data from that zip file
05:32 because this takes like half an hour to run,
05:35 you saw that zip takes like five seconds.