MongoDB for Developers with Python Transcripts
Chapter: Mapping classes to MongoDB with the ODM MongoEngine
Lecture: Introducing ODMs

Login or purchase this course to watch this video and the rest of the course contents.
0:01 Now we've got to a serious place in the course
0:03 where we're going to write some real code
0:05 and work with some realistic complex demos,
0:07 and we're going to do that using what's called an odm, an object document mapper.
0:11 So an object document mapper is like an orm, an object relational mapper
0:16 but in NoSQL, we don't have relations we have documents
0:19 so we're going to map documents to objects
0:22 rather than navigate and traverse these relationships,
0:24 and the one we're going to focus on for this course,
0:26 my favorite one, I think is one of the best, if not the best
0:30 is something called MongoEngine.
0:33 So before we get to MongoEngine, let's just look at the overall goal here,
0:37 and the features of the odm vary whether you're talking MongoEngine
0:40 or something different, but they generally follow the same principles.
0:44 So with PyMongo, this is the low level api
0:47 we have our app and we have PyMongo, we'll talk to the database;
0:50 so when we write a query that talks to PyMongo,
0:53 we work in the Python api and we send Python dictionaries to it,
0:58 which either have the prototypical documents in it
1:00 or the high level operators, in place update operators
1:03 and things like that like $addToSet,
1:06 but in order to do that, we basically write in the raw MongoDB api,
1:11 as we've seen the only real change that we go through
1:14 to go from the raw shell api of Javascript over to Python is
1:18 we're working with dictionaries and not json,
1:20 and we're working with pythonic names,
1:22 so insert_one has the underscore and lower case in Python, not in Javascript,
1:27 but this means you're working at a super low level
1:30 and for certain operations and some of the time this makes tons of sense,
1:34 it is one of the faster ways to work with MongoDB from Python.
1:38 However, most of the time, we much, much prefer having high level concepts
1:43 in our application that enforce additional things
1:47 that automatically use the best features of the PyMongo and MongoDB api
1:52 without us having to think about how that happens.
1:55 So that's when we can bring in an odm,
1:57 we have the same thing, we got our app,
1:59 now we're going to have our odm plus PyMongo,
2:02 we're going to issue a query, but this time we're not going to write in raw api code
2:06 we're going to actually issue the queries in terms of classes,
2:09 think SQLAlchemy, think Django orm type of queries here.
2:15 So we might have a book class given our previous example,
2:18 so we'd go to the book and we'd say find based on the isbn equals this and so on,
2:23 all right, so it's very similar to the Django orm
2:27 and some of the other orms that you might be familiar with.
2:29 So we work in these high level classes, and that's great
2:32 and it translates of course down to the PyMongo api,
2:35 what's better though, what's really great is
2:38 it actually leverages the really advanced in place operator,
2:41 so at least speaking of MongoEngine specifically now,
2:44 if we say pull back a class, an instance of a class
2:48 and we make a change to say for the book, we change the title and we call save,
2:51 it's actually going to do a dollar set operation, in place update
2:55 it's not just going to push the whole book back into the database
2:58 with all the optimistic concurrency issues you might run into,
3:01 no, it's going to make the changes in the best way possible.
3:04 So we'll see that we'll be able to use these advanced operators
3:08 without actually doing anything other
3:10 than just working with classes and objects in memory,
3:13 it's really really sweet; we'll also have additional features,
3:15 it automatically works with indexes for us,
3:18 it will automatically add type checking and other types of constraints
3:22 that simply don't exist in the database, but can be managed at the class level
3:26 in the object level and described there.
3:28 So here's the string field, here's an integer field
3:31 and the integer has to be greater than ten,
3:33 all of that stuff can be done through MongoEngine, in our application
3:36 but the concept of that doesn't even exist in MongoDb, right,
3:39 so you get a lot more structured, a lot more safety in it
3:42 by basically describing your schema in classes
3:46 and long as you stick to one application or share that class definition
3:50 across applications, you're in a much safer place
3:53 than just randomly sending dictionaries at the database.
3:57 So this odm style of programming, I find it to be extremely productive,
4:01 very clear and quite safe, neat, fast for most of what we got to do,
4:07 that's really my favorite way to work with MongoDB,
4:09 and I hope you'll see the power of it
4:11 and enjoy it after we go through in this chapter.