MongoDB for Developers with Python Transcripts
Chapter: What is NoSQL?
Lecture: Working with document DBs and queries styles

Login or purchase this course to watch this video and the rest of the course contents.
0:01 So let's talk about how document databases work. Here's a record from my actual online training platform
0:10 chapter 1001 from 'The Python Jumpstart by Building Ten Apps' course and this is more or less exactly what came out of the database,
0:20 with a few things taken away so it actually fits on the slide here. Now, let's break this into two pieces here, this green piece and the blue piece.
0:30 First of all, you can see we have json, when you work with document databases, you'll frequently run into json
0:36 as at least the visual representation of the record. In fact, in MongoDB it doesn't really work in terms of json
0:47 it works in something called bson or binary json, so this binary tokenised type typefull, rich typed version
0:58 of sort of extended json but already tokenised and stored as a binary version; this is what's transferred on the wire and to some degree
1:08 this is what stored actually in the database so how it actually get stored is it moves around and the database storage engines are changing
1:17 and sort of plugable now in MongoDB, but more or less you can think of this becoming a binary thing and then stored in the database.
1:25 When it comes over into say Python, we'll of course map this into something like let's say a Python dictionary
1:32 or a type that has these fields and so on. So if you look at the green area, this is just the jasonified version of any other database record,
1:42 it has let's think of it as columns if you will for a minute it would have columns here like one would be the id
1:50 one would be the title, one might be course id and it has values; and that's all well and good, until we get to lectures,
1:55 and here's where the power of document databases comes in, lectures is not just like seven, there are seven lectures or whatever
2:02 no, lectures is a list, so multiple things, and each one of those things is a lecture, an individual one, with its individual fields
2:14 so id, title, video url, duration in seconds, again there's actually more to it, but so it fits on screen right;
2:19 with this document database, you can think of these things as kind of pre-computed joints, and this solves a ton of problems
2:28 and makes the NoSQL aspect of document databases super powerful. So it makes this chapter more self contained, if I want to get this chapter back,
2:36 instead of going to the chapter and then doing a join against the lectures and maybe some other type of join,
2:43 and you're getting a bunch of different pieces and pulling them back together I just might do a query, find me the chapter with id 1001
2:51 bam, it's back, I've got the whole thing and so you can think of this as like pre-joined data if 80, 90 percent of the time I'm working with a chapter,
3:00 I care about the lecture data being there, why not store it in a way that it's already bound together, so I don't have to do that join,
3:08 I don't have to do multiple queries or things like this. Okay, so this is really powerful and we'll talk a lot
3:15 about when this makes sense, when it does not make sense and so on, but this means that if I take the single record
3:22 and I put it on some server, even if I've got like ten servers and some sort of horizontal scale situation
3:28 and I do a query by chapter id, I don't then have to go back to the cluster find where all the lecture data lives or anything like that.
3:35 No, it's just bringing that one record brings most of the data that I need to work with
3:40 when I'm working with a chapter, right along with it, which is excellent. That's the benefit, the important question the critical question to say
3:48 like is this going to work for our database system as a general thing is well can I ask the questions that I would still have asked
3:55 if lectures was its separate table, if it was a flat table just like relational databases. So, what if I want to find his last lecture here, 10 106,
4:07 will I be able to go to the database and say hey document database, I would like to get lecture 10 106 and I want to do that with an index
4:18 and I want to have it basically instantaneously, even if there's a million records, I want to instantaneously get the record
4:24 that embedded deep down within it could be many, many levels not just one, right, but in this case it's just one;
4:31 I want to get the record that deep down within it somewhere matches the fact that the lecture id is 10 106.
4:38 And the answer is for the document databases yes, so this makes them very, very different than the key value stores just doing a json blob
4:47 because we can ask these very interesting questions, we can do map reduce or aggregation type things for big data,
4:53 analysis and analytics, all sorts of stuff is possible, because you can actually query deeply down into these nested objects.
5:02 So that's how document databases work, and we'll explore the when, whys and hows of designing these documents
5:09 when we get to the document design chapter.

Talk Python's Mastodon Michael Kennedy's Mastodon