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