pymongo-tutorial.ipynb

{
 "metadata": {
  "name": "pymongo-tutorial"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "I use [mongoDB](http://www.mongodb.org/) along with [Pymongo](http://api.mongodb.org/python/current/) for personal projects only (I hope this changes in the near future though) and not very often to be honest. So this post is more of a quick reference for myself and I hope you guys finds it useful too. I am also writing this post in [Ipython](http://ipython.org/) which I will convert to [markdown](http://en.wikipedia.org/wiki/Markdown) using [nbconvert utility](http://blog.fperez.org/2012/09/blogging-with-ipython-notebook.html) and then push it to my github blog using [Jekyll](http://jekyllbootstrap.com/). Fingers crossed it won't be too difficult.\n",
      "\n",
      "For this tutorial I'll be using real data from Twitter using the [Tweepy](https://github.com/tweepy/tweepy) package.\n",
      "\n",
      "Before we start let's see what Wikipedia has to say about MongoDB:\n",
      "\n",
      "> \"MongoDB (from \"humongous\") is an open source document-oriented database system developed and supported by 10gen. It is part of the NoSQL family of database systems. Instead of storing data in tables as is done in a \"classical\" relational database, MongoDB stores structured data as JSON-like documents with dynamic schemas (MongoDB calls the format BSON), making the integration of data in certain types of applications easier and faster.\n",
      "\n",
      ">10gen began Development of MongoDB in October 2007. The database is used by MTV Networks, Craigslist, Foursquare and UIDAI Aadhaar. MongoDB is the most popular NoSQL database management system.\"\n",
      "\n",
      "Done - let's start!\n",
      "\n",
      "## Downloading & Installing MongoDB binaries\n",
      "\n",
      "1. Head to the MongoDB download page [http://www.mongodb.org/downloads](http://www.mongodb.org/downloads) and get version 2.2.2 (or latest stable version) for your OS (*by the way I'm using OSX for this tutorial so \\*nix guys should have no difficulty following along but Windows users may need to change some bits - sorry!*).\n",
      "\n",
      "2. Unzip mongodb-osx-x86_64-2.2.2.tgz and rename folder mongodb-osx-x86_64-2.2.2 to simply mongodb. I normally move this folder to my personal project folder so feel free to move it in wherever you like. Your mongodb folder should have the following structure: \n",
      "`\n",
      "altons@asgard:~/projects$ls -R mongodb\n",
      "GNU-AGPL-3.0        README              THIRD-PARTY-NOTICES bin\n",
      "mongodb/bin:\n",
      "bsondump     mongod       mongoexport  mongoimport  mongoperf    mongos       mongostat\n",
      "mongo        mongodump    mongofiles   mongooplog   mongorestore mongosniff   mongotop\n",
      "altons@asgard:~/projects$\n",
      "`\n",
      "3. Kick off the mongodb server:\n",
      "`\n",
      "altons@asgard:~/projects$ cd mongodb\n",
      "altons@asgard:~/projects/mongodb$./bin/mongod --dbpath . --nojournal &\n",
      "`\n",
      "4. Open another terminal windows and type: `altons@asgard:~/projects/mongodb$./bin/mongo`\n",
      "\n",
      "if you something like:\n",
      "`\n",
      "MongoDB shell version: 2.2.2\n",
      "connecting to: test\n",
      "Welcome to the MongoDB shell.\n",
      "For interactive help, type \"help\".\n",
      "For more comprehensive documentation, see\n",
      "\thttp://docs.mongodb.org/\n",
      "Questions? Try the support group\n",
      "\thttp://groups.google.com/group/mongodb-user\n",
      "> \n",
      "`\n",
      "then you are good to go! Type **exit** to quit and go to the previous terminal windows and hit Ctrl+C to kill the server  - we need a bit of customization first.\n",
      "\n",
      "**Note**: Sometimes (with God as my witness!) Ctrl-C doesn't kill the server and I have to do a `kill -9` on the pid where mongod still running. If that happens - you also need to remove mongodb.lock from your **dbpath** manually otherwise mongoDB will complain next time you fire it up.\n",
      "\n",
      "## The config file\n",
      "\n",
      "The option --dbpath . will save your data inside the mongodb folder - I am not a huge fan of this option. I like to keep my data separated from db binaries. So instead I'll use a config file to tell mongoDB where to store my data.\n",
      "\n",
      "Here it is my config file:\n",
      "`\n",
      "# Mongo Production server configuration\n",
      "# Author: Alberto Negron\n",
      "# created on: 26/07/2012\n",
      "\n",
      "dbpath=/Users/altons/projects/data/mongodb/                         # location where I want to store my databases - Use full path\n",
      "port = 27017                                                        # default port\n",
      "bind_ip = 127.0.0.1                                                 # default ip\n",
      "logpath = /Users/altons/projects/data/mongodb/log/mongodb.log       # location where I want to store logs - Use full path\n",
      "logappend = true                                                    # everytime I fire up mongodb the new log will be appended to a master log file\n",
      "rest=true                                                           # this option let you check server status at http:\\\\127.0.0.1:27017\n",
      "directoryperdb = true                                               # Set to true to modify the storage pattern of the data directory to store each database\u2019s\n",
      "                                                                    # files in a distinct folder. This option will create directories within the dbpath \n",
      "                                                                    # named for each directory\n",
      "\n",
      "`\n",
      "and I have saved it as mongo.conf in side the data folder ` (~/projects/data) `.\n",
      "\n",
      "Now go back to the mongodb folder and use the following command to fire up the server:\n",
      "\n",
      "`\n",
      "altons@asgard:~/projects/mongodb$./bin/mongod --config=/Users/altons/projects/data/mongo.conf  --nojournal &\n",
      "`\n",
      "\n",
      "Since the option rest is set to true you can check mongodb status via [http://127.0.0.1:28017/](http://127.0.0.1:28017/)\n",
      "\n",
      "You can have  multiple config files (Prod/Dev/Test) or any combination of servers running on different ports. Options are endless.\n",
      "\n",
      "## Pymongo\n",
      "\n",
      "PyMongo is a Python distribution containing tools for working with MongoDB, and is the recommended way to work with MongoDB from Python. You can install mongodb from either pip or easy_install.\n",
      "\n",
      "### Connecting to MongoDB"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In Pymongo 2.4.1 the connection method has been deprecated. Now we most use MongoClient"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import pymongo\n",
      "\n",
      "# Connection to Mongo DB\n",
      "try:\n",
      "    conn=pymongo.MongoClient()\n",
      "    print \"Connected successfully!!!\"\n",
      "except pymongo.errors.ConnectionFailure, e:\n",
      "   print \"Could not connect to MongoDB: %s\" % e \n",
      "conn"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Connected successfully!!!\n"
       ]
      },
      {
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "MongoClient('localhost', 27017)"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We are now connected to our server.\n",
      "\n",
      "### Databases\n",
      "\n",
      "Mongodb creates databases and collections automatically for you if they don't exist already. A single instance of MongoDB can support multiple independent databases. When working with PyMongo you access databases using attribute style access:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db = conn.mydb\n",
      "db\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "Database(MongoClient('localhost', 27017), u'mydb')"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If your database name is such that using attribute style access won\u2019t work (like db-name), you can use dictionary style access instead:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db = conn['sandpit-test']\n",
      "db"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "Database(MongoClient('localhost', 27017), u'sandpit-test')"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you need to know what databases are available:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "conn.database_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "[u'local']"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We already created 2 new databases. Why didn't show up with the above command? Well, databases with no collections or with empty collections will not show up with database_names(). Same goes when we try to list empty collections in a database.\n",
      "\n",
      "We'll test it again once we have populate some collections.\n",
      "\n",
      "### Collections\n",
      "\n",
      "A collection is a group of documents stored in MongoDB, and can be thought of as roughly the equivalent of a table in a relational database. Getting a collection in PyMongo works the same as getting a database:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "collection = db.my_collection\n",
      "collection"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "Collection(Database(MongoClient('localhost', 27017), u'sandpit-test'), u'my_collection')"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db.collection_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "[]"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However one must be careful when trying to get existing collections. For example, if you a collection db.user and you type db.usr this is clearly a typo. Unlike an RDBMS, MongoDB won't protect you from this class of mistake.\n",
      "\n",
      "\n",
      "### Documents\n",
      "\n",
      "MongoDB stores structured data as JSON-like documents, using dynamic schemas (called BSON), rather than predefined schemas. An element of data is called a document, and documents are stored in collections. One collection may have any number of documents.\n",
      "\n",
      "Compared to relational databases, we could say collections are like tables, and documents are like records. But there is one big difference: every record in a table has the same fields (with, usually, differing values) in the same order, while each document in a collection can have completely different fields from the other documents. \n",
      "\n",
      "All you really need to know when you're using Python, however, is that documents are Python dictionaries that can have strings as keys and can contain various primitive types (int, float,unicode, datetime) as well as other documents (Python dicts) and arrays (Python lists).\n",
      "\n",
      "To insert some data into MongoDB, all we need to do is create a dict and call .insert() on the collection object:\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "doc = {\"name\":\"Alberto\",\"surname\":\"Negron\",\"twitter\":\"@Altons\"}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now we need to insert the above document into a collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "collection.insert(doc)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "ObjectId('50f89eb16577e466cf550b33')"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Congratulations you have created your first document!!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "conn.database_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 28,
       "text": [
        "[u'sandpit-test', u'local']"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db.collection_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "[u'system.indexes', u'my_collection']"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " Now database_names() and collection_names() show database **sandpit-test** and collection **my_collection**.\n",
      "\n",
      "To recap, we have **databases** containing **collections**. A **collection** is made up of **documents**. Each document is made up of **fields**.\n",
      "\n",
      "\n",
      "## Tweepy\n",
      "\n",
      "Before continue with the tutorial, let's get some real data from twitter and insert it in a new database - it'll be definitely more interesting!!!\n",
      "\n",
      "Let's pull the first 10 result pages with the keyword 'BigData'"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from tweepy import API"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lookup ='BigData'\n",
      "api = API()\n",
      "\n",
      "search = []\n",
      "page = 1\n",
      "maxPage = 10\n",
      "while(page<=maxPage):\n",
      "    tweets = api.search(lookup,page = page)\n",
      "    for tweet in tweets:\n",
      "        search.append(tweet)\n",
      "    page = page + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 51
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's how many tweets we got from the above search:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len(search)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 52,
       "text": [
        "149"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Not bad, let inspect the structure of the first object:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(search[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 53,
       "text": [
        "['__class__',\n",
        " '__delattr__',\n",
        " '__dict__',\n",
        " '__doc__',\n",
        " '__format__',\n",
        " '__getattribute__',\n",
        " '__getstate__',\n",
        " '__hash__',\n",
        " '__init__',\n",
        " '__module__',\n",
        " '__new__',\n",
        " '__reduce__',\n",
        " '__reduce_ex__',\n",
        " '__repr__',\n",
        " '__setattr__',\n",
        " '__sizeof__',\n",
        " '__str__',\n",
        " '__subclasshook__',\n",
        " '__weakref__',\n",
        " '_api',\n",
        " 'created_at',\n",
        " 'from_user',\n",
        " 'from_user_id',\n",
        " 'from_user_id_str',\n",
        " 'from_user_name',\n",
        " 'geo',\n",
        " 'id',\n",
        " 'id_str',\n",
        " 'iso_language_code',\n",
        " 'metadata',\n",
        " 'parse',\n",
        " 'parse_list',\n",
        " 'profile_image_url',\n",
        " 'profile_image_url_https',\n",
        " 'source',\n",
        " 'text',\n",
        " 'to_user',\n",
        " 'to_user_id',\n",
        " 'to_user_id_str',\n",
        " 'to_user_name']"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is a lot of information that we really don't need. Let's keep only the data related to the tweet and insert it into MongoDB"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Define my mongoDB database\n",
      "db = conn.twitter_results\n",
      "# Define my collection where I'll insert my search\n",
      "posts = db.posts\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 54
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "\n",
      "# loop through search and insert dictionary into mongoDB\n",
      "for tweet in search:\n",
      "    # Empty dictionary for storing tweet related data\n",
      "    data ={}\n",
      "    data['created_at'] = tweet.created_at\n",
      "    data['from_user'] = tweet.from_user\n",
      "    data['from_user_id'] = tweet.from_user_id\n",
      "    data['from_user_id_str'] = tweet.from_user_id_str\n",
      "    data['from_user_name'] = tweet.from_user_name\n",
      "    data['geo'] = tweet.geo\n",
      "    data['id'] = tweet.id\n",
      "    data['iso_language_code'] = tweet.iso_language_code\n",
      "    data['source'] = tweet.source\n",
      "    data['text'] = tweet.text\n",
      "    data['to_user'] = tweet.to_user\n",
      "    data['to_user_id'] = tweet.to_user_id\n",
      "    data['to_user_id_str'] = tweet.to_user_id_str\n",
      "    data['to_user_name'] = tweet.to_user_name\n",
      "    # Insert process\n",
      "    posts.insert(data)\n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Dead easy! we have created our collection of tweets, no need to define table and columns beforehand - that's the beauty of MongoDB.\n",
      "\n",
      "Here it is the structure of the last document inserted:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 58,
       "text": [
        "{'_id': ObjectId('50f99bf66577e466cf550bc8'),\n",
        " 'created_at': datetime.datetime(2013, 1, 18, 18, 1, 38),\n",
        " 'from_user': u'Adriana_iSchool',\n",
        " 'from_user_id': 303810955,\n",
        " 'from_user_id_str': u'303810955',\n",
        " 'from_user_name': u'Adriana Rossini',\n",
        " 'geo': None,\n",
        " 'id': 292330927105916928L,\n",
        " 'iso_language_code': u'en',\n",
        " 'source': u'Twuffer',\n",
        " 'text': u'New big data firm to pioneer topological data analysis http://t.co/uEHYdcnM via @guardian #BigData #topology',\n",
        " 'to_user': None,\n",
        " 'to_user_id': 0,\n",
        " 'to_user_id_str': u'0',\n",
        " 'to_user_name': None}"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### The _id field\n",
      "\n",
      "\n",
      "In MongoDB, documents stored in a collection require a unique _id field that acts as a primary key. Because ObjectIds are small, most likely unique, and fast to generate, MongoDB uses ObjectIds as the default value for the _id field if the _id field is not specified; i.e., the mongod adds the _id field and generates a unique ObjectId to assign as its value\n",
      "\n",
      "## Reading Documents in a Collection\n",
      "\n",
      "The first and foremost important operation we need to learn is how to retrieve our data from MongoDB. For this, Collections provide the find_one() and find() methods:\n",
      "\n",
      "- The find_one() method selects and returns a single document from a collection and returns that document (or None if there are no matches). It is useful when you know there is only one matching document, or are only interested in the first match:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find_one()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 60,
       "text": [
        "{u'_id': ObjectId('50f99bf66577e466cf550b34'),\n",
        " u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1),\n",
        " u'from_user': u'BITechWatch',\n",
        " u'from_user_id': 22631958,\n",
        " u'from_user_id_str': u'22631958',\n",
        " u'from_user_name': u'Marly Cho',\n",
        " u'geo': None,\n",
        " u'id': 292341338840653825L,\n",
        " u'iso_language_code': u'en',\n",
        " u'source': u'twitterfeed',\n",
        " u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\",\n",
        " u'to_user': None,\n",
        " u'to_user_id': 0,\n",
        " u'to_user_id_str': u'0',\n",
        " u'to_user_name': None}"
       ]
      }
     ],
     "prompt_number": 60
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- To get more than a single document as the result of a query we use the find() method. find() returns a Cursor instance, which allows us to iterate over all matching documents. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "posts.find()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "For example, we can iterate over the first 2 documents (there are a lot in the collection and this is just an example) in the posts collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for d in posts.find()[:2]:\n",
      "    print d\n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{u'iso_language_code': u'en', u'to_user_name': None, u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1), u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\", u'from_user_id_str': u'22631958', u'to_user_id_str': u'0', u'to_user': None, u'source': u'twitterfeed', u'to_user_id': 0, u'from_user': u'BITechWatch', u'id': 292341338840653825L, u'from_user_id': 22631958, u'_id': ObjectId('50f99bf66577e466cf550b34'), u'geo': None, u'from_user_name': u'Marly Cho'}\n",
        "{u'iso_language_code': u'en', u'to_user_name': None, u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1), u'text': u'RT @IBMcloud: Big data in the #cloud? Governing a sprawling business resource http://t.co/FDsoNfrf via @jameskobielus #bigdata', u'from_user_id_str': u'115674359', u'to_user_id_str': u'0', u'to_user': None, u'source': u'web', u'to_user_id': 0, u'from_user': u'ibmmb', u'id': 292341338798690304L, u'from_user_id': 115674359, u'_id': ObjectId('50f99bf66577e466cf550b35'), u'geo': None, u'from_user_name': u'Maarten Boerma'}\n"
       ]
      }
     ],
     "prompt_number": 66
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "you can also use the standard python list():"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "list(posts.find())[:2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 64,
       "text": [
        "[{u'_id': ObjectId('50f99bf66577e466cf550b34'),\n",
        "  u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1),\n",
        "  u'from_user': u'BITechWatch',\n",
        "  u'from_user_id': 22631958,\n",
        "  u'from_user_id_str': u'22631958',\n",
        "  u'from_user_name': u'Marly Cho',\n",
        "  u'geo': None,\n",
        "  u'id': 292341338840653825L,\n",
        "  u'iso_language_code': u'en',\n",
        "  u'source': u'twitterfeed',\n",
        "  u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\",\n",
        "  u'to_user': None,\n",
        "  u'to_user_id': 0,\n",
        "  u'to_user_id_str': u'0',\n",
        "  u'to_user_name': None},\n",
        " {u'_id': ObjectId('50f99bf66577e466cf550b35'),\n",
        "  u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1),\n",
        "  u'from_user': u'ibmmb',\n",
        "  u'from_user_id': 115674359,\n",
        "  u'from_user_id_str': u'115674359',\n",
        "  u'from_user_name': u'Maarten Boerma',\n",
        "  u'geo': None,\n",
        "  u'id': 292341338798690304L,\n",
        "  u'iso_language_code': u'en',\n",
        "  u'source': u'web',\n",
        "  u'text': u'RT @IBMcloud: Big data in the #cloud? Governing a sprawling business resource http://t.co/FDsoNfrf via @jameskobielus #bigdata',\n",
        "  u'to_user': None,\n",
        "  u'to_user_id': 0,\n",
        "  u'to_user_id_str': u'0',\n",
        "  u'to_user_name': None}]"
       ]
      }
     ],
     "prompt_number": 64
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Counting\n",
      "\n",
      "If we just want to know how many documents match a query we can perform a count() operation instead of a full query. We can get a count of all of the documents in a collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 67,
       "text": [
        "149"
       ]
      }
     ],
     "prompt_number": 67
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find().count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 69,
       "text": [
        "149"
       ]
      }
     ],
     "prompt_number": 69
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Query Operators\n",
      "\n",
      "MongoDB queries are represented as JSON-like structure, just like documents. To build a query, you just need to specify a dictionary with the properties you wish the results to match. For example, this query will match all documents in the posts collection with ISO language code \"en\"."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find({\"iso_language_code\": \"en\"}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 72,
       "text": [
        "126"
       ]
      }
     ],
     "prompt_number": 72
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If we wanted to retrieve all documents with ISO language code \"en\" and source equal to \"twitterfeed\":"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find({\"iso_language_code\":\"en\",\"source\":\"twitterfeed\"}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 76,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 76
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Queries can also use special query operators. These operators include **gt, gte, lt, lte, ne, nin, regex, exists, not, or**, and many more. The following queries show the use of some of these operators."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from datetime import datetime\n",
      "# cheat: year, month, day, hour, minute, second, microsecond\n",
      "date1 = datetime.strptime(\"18/01/13 18:30\", \"%d/%m/%y %H:%M\")\n",
      "date2 = datetime.strptime(\"18/01/13 18:05\", \"%d/%m/%y %H:%M\")\n",
      "date3 = datetime.strptime(\"18/01/13 18:10\", \"%d/%m/%y %H:%M\")\n",
      "date4 = datetime.strptime(\"18/01/13 18:25\", \"%d/%m/%y %H:%M\")\n",
      "\n",
      "cursor = posts.find({'created_at':{\"$gt\":date1}})\n",
      "cursor.next()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 108,
       "text": [
        "{u'_id': ObjectId('50f99bf66577e466cf550b34'),\n",
        " u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1),\n",
        " u'from_user': u'BITechWatch',\n",
        " u'from_user_id': 22631958,\n",
        " u'from_user_id_str': u'22631958',\n",
        " u'from_user_name': u'Marly Cho',\n",
        " u'geo': None,\n",
        " u'id': 292341338840653825L,\n",
        " u'iso_language_code': u'en',\n",
        " u'source': u'twitterfeed',\n",
        " u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\",\n",
        " u'to_user': None,\n",
        " u'to_user_id': 0,\n",
        " u'to_user_id_str': u'0',\n",
        " u'to_user_name': None}"
       ]
      }
     ],
     "prompt_number": 108
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This time we will do the same query but add the count() method to only get the count of documents that match the query. We will use count() from now onwards (easier!!!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find({'created_at':{\"$gt\":date1}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 109,
       "text": [
        "44"
       ]
      }
     ],
     "prompt_number": 109
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Tweets dates low than or equal to date2\n",
      "posts.find({'created_at':{\"$lte\":date2}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 110,
       "text": [
        "14"
       ]
      }
     ],
     "prompt_number": 110
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Between 2 dates\n",
      "posts.find({\"created_at\": {\"$gte\": date3, \"$lt\": date4}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 111,
       "text": [
        "52"
       ]
      }
     ],
     "prompt_number": 111
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Posts in either spanish or french\n",
      "posts.find({\"iso_language_code\":{\"$in\":[\"es\",\"fr\"]}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 112,
       "text": [
        "7"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Posts in either spanish or french using $or\n",
      "posts.find({\"$or\":[{\"iso_language_code\":\"es\"},{\"iso_language_code\":\"fr\"}]}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 115,
       "text": [
        "7"
       ]
      }
     ],
     "prompt_number": 115
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# All posts except spanish or french\n",
      "posts.find({\"iso_language_code\":{\"$nin\":[\"es\",\"fr\"]}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 113,
       "text": [
        "142"
       ]
      }
     ],
     "prompt_number": 113
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Using Regex to find a post with hashtag #analytics\n",
      "import re\n",
      "regex = re.compile(r'#analytics')\n",
      "rstats = posts.find_one({\"text\":regex})\n",
      "rstats"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 122,
       "text": [
        "{u'_id': ObjectId('50f99bf66577e466cf550b3b'),\n",
        " u'created_at': datetime.datetime(2013, 1, 18, 18, 41, 23),\n",
        " u'from_user': u'DGleebits',\n",
        " u'from_user_id': 364557525,\n",
        " u'from_user_id_str': u'364557525',\n",
        " u'from_user_name': u'Dan Gleebits ',\n",
        " u'geo': None,\n",
        " u'id': 292340928268623872L,\n",
        " u'iso_language_code': u'en',\n",
        " u'source': u'Tweet Button',\n",
        " u'text': u'LazyWeb Reblog of Big Data Security Challenges http://t.co/vAY5CVOz via @wordpressdotcom #infosec #dfir #bigdata #analytics',\n",
        " u'to_user': None,\n",
        " u'to_user_id': 0,\n",
        " u'to_user_id_str': u'0',\n",
        " u'to_user_name': None}"
       ]
      }
     ],
     "prompt_number": 122
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We'll cover other operators further down once we have covered the Update process.\n",
      "\n",
      "## Sorting Documents\n",
      "\n",
      "MongoDB can sort query results for you on the server-side. Especially if you are sorting results on a property which has an index, it can sort these far more efficiently than your client program can.\n",
      "\n",
      "Here's an exmaple of using a descending sort to get the last tweet in our collection."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lastTweet = posts.find().sort([(\"created_at\", pymongo.DESCENDING)])\n",
      "lastTweet.next()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 125,
       "text": [
        "{u'_id': ObjectId('50f99bf66577e466cf550b34'),\n",
        " u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1),\n",
        " u'from_user': u'BITechWatch',\n",
        " u'from_user_id': 22631958,\n",
        " u'from_user_id_str': u'22631958',\n",
        " u'from_user_name': u'Marly Cho',\n",
        " u'geo': None,\n",
        " u'id': 292341338840653825L,\n",
        " u'iso_language_code': u'en',\n",
        " u'source': u'twitterfeed',\n",
        " u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\",\n",
        " u'to_user': None,\n",
        " u'to_user_id': 0,\n",
        " u'to_user_id_str': u'0',\n",
        " u'to_user_name': None}"
       ]
      }
     ],
     "prompt_number": 125
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "What about the first tweet in french?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "frlastTweet = posts.find({\"iso_language_code\":\"fr\"}).sort([(\"created_at\", pymongo.ASCENDING)])\n",
      "frlastTweet.next()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 130,
       "text": [
        "{u'_id': ObjectId('50f99bf66577e466cf550b99'),\n",
        " u'created_at': datetime.datetime(2013, 1, 18, 18, 13, 52),\n",
        " u'from_user': u'jbmgrtn',\n",
        " u'from_user_id': 87185256,\n",
        " u'from_user_id_str': u'87185256',\n",
        " u'from_user_name': u'J\\xe9r\\xf4me Baumgarten',\n",
        " u'geo': None,\n",
        " u'id': 292334004466761729L,\n",
        " u'iso_language_code': u'fr',\n",
        " u'source': u'Twitter for iPhone',\n",
        " u'text': u'@jhattat la pr\\xe9s dont je parlais sur BigData et Hadoop http://t.co/4McdjN80',\n",
        " u'to_user': u'jhattat',\n",
        " u'to_user_id': 24175910,\n",
        " u'to_user_id_str': u'24175910',\n",
        " u'to_user_name': u'J\\xe9r\\xe9mie HATTAT'}"
       ]
      }
     ],
     "prompt_number": 130
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The above queries are not very optimal when you have large result sets. Pymongo have a limit() method which let you fetch a limited number of results."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lastTweetOnly = posts.find().sort([(\"created_at\", pymongo.DESCENDING)]).limit(1)\n",
      "for t in lastTweetOnly: print t"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{u'iso_language_code': u'en', u'to_user_name': None, u'created_at': datetime.datetime(2013, 1, 18, 18, 43, 1), u'text': u\"Everything you ever wanted to know about R functions: It's hard to overstate the importance of function... http://t.co/sD5bG4yg #bigdata\", u'from_user_id_str': u'22631958', u'to_user_id_str': u'0', u'to_user': None, u'source': u'twitterfeed', u'to_user_id': 0, u'from_user': u'BITechWatch', u'id': 292341338840653825L, u'from_user_id': 22631958, u'_id': ObjectId('50f99bf66577e466cf550b34'), u'geo': None, u'from_user_name': u'Marly Cho'}\n"
       ]
      }
     ],
     "prompt_number": 136
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Updating Documents\n",
      "\n",
      "PyMongo can update documents in a number of different ways. Let's start for adding a new document to our collection.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.insert({\"_id\":1234,\"created_at\":datetime(2013,1,21,15,27,59),\"text\":\"Hello World\", \"from_user\":\"Altons\",\"source\":\"Ipython\"})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 138,
       "text": [
        "1234"
       ]
      }
     ],
     "prompt_number": 138
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 139,
       "text": [
        "{u'_id': 1234,\n",
        " u'created_at': datetime.datetime(2013, 1, 21, 15, 27, 59),\n",
        " u'from_user': u'Altons',\n",
        " u'source': u'Ipython',\n",
        " u'text': u'Hello World'}"
       ]
      }
     ],
     "prompt_number": 139
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now we can use the update() method to modify the document. This operation finds the document we just inserted by _id and updates it with a new document."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"from_user\":\"anonymous\"})\n",
      "\n",
      "#Fetch our updated document\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 141,
       "text": [
        "{u'_id': 1234, u'from_user': u'anonymous'}"
       ]
      }
     ],
     "prompt_number": 141
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The update() method replaces the whole document so be careful! If instead we want to modify specific fields of the document we can use MongoDB's update operators like **set, inc, push, pull** and many more.\n",
      "\n",
      "### Update Operator: set\n",
      "\n",
      "This statement updates in the document in collection where field matches value1 by replacing the value of the field field1 with value2. This operator will add the specified field or fields if they do not exist in this document or replace the existing value of the specified field(s) if they already exist."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$set\":{\"from_user\":\"Altons\",\"source\":\"Ipython notebook\"}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 143,
       "text": [
        "{u'_id': 1234, u'from_user': u'Altons', u'source': u'Ipython notebook'}"
       ]
      }
     ],
     "prompt_number": 143
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Upsert**\n",
      "\n",
      "An **upsert** eliminates the need to perform a separate database call to check for the existence of a record before performing either an update or an insert operation. Typically update operations update existing documents, but in MongoDB, the update() operation can accept an **upsert** option as an argument. Upserts are a hybrid operation that use the **query** argument to determine the write operation:\n",
      "\n",
      "- If the query matches an existing document(s), the upsert performs an update.\n",
      "- If the query matches no document in the collection, the upsert inserts a single document.\n",
      "\n",
      "Let's see an example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$set\":{\"from_user\":\"Alberto\",\"source\":\"unavailable\"}})\n",
      "posts.find({\"_id\":5678}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 152,
       "text": [
        "0"
       ]
      }
     ],
     "prompt_number": 152
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The update fails because no document matched the query for the update. But using upsert will sort this out:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$set\":{\"from_user\":\"Alberto\",\"source\":\"unavailable\"}}, upsert=True)\n",
      "posts.find({\"_id\":5678}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 153,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 153
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**multi=True**\n",
      "\n",
      "By default MongoDB only modifies the first document that matches the query. If you want to modify all documents that match the query add multi=True."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: inc\n",
      "\n",
      "The inc operator increments a value by a specified amount if field is present in the document. If the field does not exist, $inc sets field to the number value. For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$set\":{\"total_posts\":1}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 144,
       "text": [
        "{u'_id': 1234,\n",
        " u'from_user': u'Altons',\n",
        " u'source': u'Ipython notebook',\n",
        " u'total_posts': 1}"
       ]
      }
     ],
     "prompt_number": 144
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Increment total_posts by 9 tweets\n",
      "posts.update({\"_id\":1234},{\"$inc\":{\"total_posts\":9}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 145,
       "text": [
        "{u'_id': 1234,\n",
        " u'from_user': u'Altons',\n",
        " u'source': u'Ipython notebook',\n",
        " u'total_posts': 10}"
       ]
      }
     ],
     "prompt_number": 145
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Update Operator: unset\n",
      "\n",
      "The unset operator deletes a particular field. If documents match the initial query but do not have the field specified in the unset operation, there the statement has no effect on the document.\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$unset\":{\"total_posts\":\"\"}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 149,
       "text": [
        "{u'_id': 1234, u'from_user': u'Altons', u'source': u'Ipython notebook'}"
       ]
      }
     ],
     "prompt_number": 149
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: rename\n",
      "\n",
      "The rename operator updates the name of a field. The new field name must differ from the existing field name."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$rename\":{\"from_user\":\"username\"}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 150,
       "text": [
        "{u'_id': 1234, u'source': u'Ipython notebook', u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 150
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here we have a good opportunity to see **exists** in action (it should return only 1 as there only one document with field **username**):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find({\"username\":{\"$exists\":True}}).count()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 161,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 161
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: push \n",
      "\n",
      "The **push** operator appends a specified value to an array.Be aware of the following behaviors:\n",
      "\n",
      "- If the field specified in the **push** statement (e.g. { $push: { field: value1 } }) does not exist in the matched document, the operation adds a new array with the specified field and value (e.g. value1) to the matched document.\n",
      "- The operation will fail if the field specified in the **push** statement is not an array. $push does not fail when pushing a value to a non-existent field.\n",
      "- If value1 is an array itself, **push** appends the whole array as an element in the identified array. To add multiple items to an array, use [pushAll](http://docs.mongodb.org/manual/reference/operator/pushAll/#_S_pushAll).\n",
      "\n",
      "Now for this example, let's say we have 2 predictive models that score the sentiment of each tweet in the range -5,5 (-5 = worse, 0 = neutral and 5=best) and we want to add those scores to each document.\n",
      "\n",
      "Let's use our well known document _id=1234"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import random\n",
      "\n",
      "posts.update({\"_id\":1234},{\"$push\":{\"sentiment\":{\"nb\":random.randint(-5, 5),\"svm\":random.randint(-5, 5)}}})\n",
      "posts.find_one({\"_id\":1234})\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 166,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': 0, u'svm': -2}],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 166
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the above example we have added scores to document 1234, let's see what happens if we run the same code again."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$push\":{\"sentiment\":{\"nb\":random.randint(-5, 5),\"svm\":random.randint(-5, 5)}}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 167,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': 0, u'svm': -2}, {u'nb': 1, u'svm': 4}],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 167
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "it will add another array as expected. I don't know why one would think it will update the original array instead of appending a new one. So don't make the mistake I did!\n",
      "\n",
      "if you run it twice or more you always have the **unset** operator to the rescue (if you want to start from scratch!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$unset\":{\"sentiment\":\"\"}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 168,
       "text": [
        "{u'_id': 1234, u'source': u'Ipython notebook', u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 168
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: pop\n",
      "\n",
      "The **pop** operator removes the first or last element of an array. Pass **pop** a value of 1 to remove the last element in an array and a value of -1 to remove the first element of an array.\n",
      "\n",
      "Be aware of the following **pop** behaviors:\n",
      "\n",
      "- The **pop** operation fails if field is not an array.\n",
      "- **pop** will successfully remove the last item in an array. field will then hold an empty array.\n",
      "\n",
      "We can use **pop** if we don't want to start (or can't) from scratch:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$push\":{\"sentiment\":{\"nb\":random.randint(-5, 5),\"svm\":random.randint(-5, 5)}}})\n",
      "posts.update({\"_id\":1234},{\"$push\":{\"sentiment\":{\"nb\":random.randint(-5, 5),\"svm\":random.randint(-5, 5)}}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 190,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}, {u'nb': 4, u'svm': 2}],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 190
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":1234},{\"$pop\":{\"sentiment\":1}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 191,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 191
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: pull\n",
      "\n",
      "The **pull** operator removes all instances of a value from an existing array. If the value existed multiple times in the field array, **pull** would remove all instances of this value in this array.\n",
      "\n",
      "It is very handy when you exactly what value you want to remove."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$set\":{\"skills\":[\"python\",\"SAS\",\"R\",\"javascript\",\"java\"]}})\n",
      "posts.find_one({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 174,
       "text": [
        "{u'_id': 5678,\n",
        " u'from_user': u'Alberto',\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript', u'java'],\n",
        " u'source': u'unavailable'}"
       ]
      }
     ],
     "prompt_number": 174
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$pull\":{\"skills\":\"java\"}})\n",
      "posts.find_one({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 175,
       "text": [
        "{u'_id': 5678,\n",
        " u'from_user': u'Alberto',\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript'],\n",
        " u'source': u'unavailable'}"
       ]
      }
     ],
     "prompt_number": 175
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Update Operator: addToSet\n",
      "\n",
      "The **addToSet** operator adds a value to an array only if the value is not in the array already. If the value is in the array, **addToSet** returns without modifying the array. Otherwise, **addToSet** behaves the same as **push**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.find_one({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 176,
       "text": [
        "{u'_id': 5678,\n",
        " u'from_user': u'Alberto',\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript'],\n",
        " u'source': u'unavailable'}"
       ]
      }
     ],
     "prompt_number": 176
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$addToSet\":{\"skills\":\"python\"}})\n",
      "posts.find_one({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 177,
       "text": [
        "{u'_id': 5678,\n",
        " u'from_user': u'Alberto',\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript'],\n",
        " u'source': u'unavailable'}"
       ]
      }
     ],
     "prompt_number": 177
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "posts.update({\"_id\":5678},{\"$addToSet\":{\"skills\":\"Perl\"}})\n",
      "posts.find_one({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 178,
       "text": [
        "{u'_id': 5678,\n",
        " u'from_user': u'Alberto',\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript', u'Perl'],\n",
        " u'source': u'unavailable'}"
       ]
      }
     ],
     "prompt_number": 178
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Update Operator: $\n",
      "\n",
      "The positional $ operator identifies an element in an array field to update without explicitly specifying the position of the element in the array. The positional operator, when used with the update() method and acts as a placeholder for the first match of the update query selector."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# sample document\n",
      "posts.update({\"_id\":1234},{\"$set\":{\"skills\":[\"python\",\"SAS\",\"R\",\"javascript\",\"java\"]}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 192,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}],\n",
        " u'skills': [u'python', u'SAS', u'R', u'javascript', u'java'],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 192
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# update R to Rstats\n",
      "posts.update({\"_id\":1234,\"skills\":\"R\"},{ \"$set\": { \"skills.$\" : \"Rstats\" }})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 193,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}],\n",
        " u'skills': [u'python', u'SAS', u'Rstats', u'javascript', u'java'],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 193
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Another example\n",
      "posts.update({\"_id\":1234},{\"$push\":{\"sentiment\":{\"nb\":random.randint(-5, 5),\"svm\":random.randint(-5, 5)}}})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 194,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}, {u'nb': 1, u'svm': 4}],\n",
        " u'skills': [u'python', u'SAS', u'Rstats', u'javascript', u'java'],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 194
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use the positional $ operator to update the value of the nb field to zero in the embedded document with the svm of 4:\n",
      "posts.update({\"_id\":1234,\"sentiment.svm\":4},{ \"$set\": { \"sentiment.$.nb\" : 0 }})\n",
      "posts.find_one({\"_id\":1234})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 196,
       "text": [
        "{u'_id': 1234,\n",
        " u'sentiment': [{u'nb': -5, u'svm': 0}, {u'nb': 0, u'svm': 4}],\n",
        " u'skills': [u'python', u'SAS', u'Rstats', u'javascript', u'java'],\n",
        " u'source': u'Ipython notebook',\n",
        " u'username': u'Altons'}"
       ]
      }
     ],
     "prompt_number": 196
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Removing Data\n",
      "\n",
      "Removing databases, collections and documents in Pymongo is a straight forward process:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "conn.database_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 197,
       "text": [
        "[u'sandpit-test', u'twitter_results', u'local']"
       ]
      }
     ],
     "prompt_number": 197
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Remove database sandpit-test\n",
      "conn.drop_database(\"sandpit-test\")\n",
      "conn.database_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 198,
       "text": [
        "[u'twitter_results', u'local']"
       ]
      }
     ],
     "prompt_number": 198
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a database, then a collection and a dummy document\n",
      "conn.dummy.dummy_collection.insert({\"greeting\":\"Hello World\"})\n",
      "conn.dummy.collection_names()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 201,
       "text": [
        "[u'system.indexes', u'dummy_collection']"
       ]
      }
     ],
     "prompt_number": 201
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "conn.dummy.collection_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 202,
       "text": [
        "[u'system.indexes', u'dummy_collection']"
       ]
      }
     ],
     "prompt_number": 202
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Delete a collection\n",
      "conn.dummy.drop_collection(\"dummy_collection\")\n",
      "conn.dummy.collection_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 203,
       "text": [
        "[u'system.indexes']"
       ]
      }
     ],
     "prompt_number": 203
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Delete dummy database\n",
      "conn.drop_database(\"dummy\")\n",
      "conn.database_names()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 204,
       "text": [
        "[u'twitter_results', u'local']"
       ]
      }
     ],
     "prompt_number": 204
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Remove documents.\n",
      "#  Please note that there is no multi=True option for remove. MongoDB will remove any documents that match the query\n",
      "posts.remove({\"_id\":5678})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 199,
       "text": [
        "{u'connectionId': 5, u'err': None, u'n': 1, u'ok': 1.0}"
       ]
      }
     ],
     "prompt_number": 199
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If we don't specify what documents to remove MongoDB will remove them all. This just removes the documents. The collection and its indexes still exist."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Useful Commands\n",
      "\n",
      "If you need to get some statistics about your collections."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db.command({'dbstats': 1})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 211,
       "text": [
        "{u'avgObjSize': 400.46753246753246,\n",
        " u'collections': 3,\n",
        " u'dataSize': 61672,\n",
        " u'db': u'twitter_results',\n",
        " u'fileSize': 201326592,\n",
        " u'indexSize': 8176,\n",
        " u'indexes': 1,\n",
        " u'nsSizeMB': 16,\n",
        " u'numExtents': 4,\n",
        " u'objects': 154,\n",
        " u'ok': 1.0,\n",
        " u'storageSize': 155648}"
       ]
      }
     ],
     "prompt_number": 211
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To get collection statistics use the collstats command:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "db.command({'collstats': 'posts'})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 212,
       "text": [
        "{u'avgObjSize': 409.76,\n",
        " u'count': 150,\n",
        " u'indexSizes': {u'_id_': 8176},\n",
        " u'lastExtentSize': 114688,\n",
        " u'nindexes': 1,\n",
        " u'ns': u'twitter_results.posts',\n",
        " u'numExtents': 2,\n",
        " u'ok': 1.0,\n",
        " u'paddingFactor': 1.0000000000000004,\n",
        " u'size': 61464,\n",
        " u'storageSize': 143360,\n",
        " u'systemFlags': 1,\n",
        " u'totalIndexSize': 8176,\n",
        " u'userFlags': 0}"
       ]
      }
     ],
     "prompt_number": 212
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Things I did not covered in this tutorial\n",
      "\n",
      "- [Aggregation Framework](http://docs.mongodb.org/manual/reference/aggregation/) (Still chinese to me).\n",
      "- [Map Reduce](http://docs.mongodb.org/manual/applications/map-reduce/)\n",
      "- [GridFS](http://docs.mongodb.org/manual/applications/gridfs/)\n",
      "- [Journaling](http://docs.mongodb.org/manual/administration/journaling/) "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "I hope you find this tutorial useful. I'll be using it as my online cheat sheet! "
     ]
    }
   ],
   "metadata": {}
  }
 ]
}