##MONGODB & PYTHON

###Ubuntu Install
```
sudo apt-get install mongodb
pip install pymongo
```
Table - Collection  
Column - Property  
Row - Document  
Node - Single Instance of the MongoDB daemon process

###Connecting to MongoDB
```
""" An example of how to connect to MongoDB """
import sys
from pymongo import Connection
from pymongo.errors import ConnectionFailure

def main():
    """ Connect to MongoDB """
    try:
        c = Connection(host="localhost", port=27017)
        print "Connected successfully"
        print c
    except ConnectionFailure, e:
        sys.stderr.write("Could not connect to MongoDB: %s" % e)
        sys.exit(1)
if __name__ == "__main__": main()
```
###Getting a Database Handle
```
""" An example of how to get a Python handle to a MongoDB database """
import sys
from pymongo import Connection
from pymongo.errors import ConnectionFailure
def main():
    """ Connect to MongoDB """
    try:
        c = Connection(host="localhost", port=27017)
    except ConnectionFailure, e:
        sys.stderr.write("Could not connect to MongoDB: %s" % e)
        sys.exit(1)
    # Get a Database handle to a database named "mydb"
    dbh = c["mydb"]
    # Demonstrate the db.connection property to retrieve a reference to the
    # Connection object should it go out of scope. In most cases, keeping a
    # reference to the Database object for the lifetime of your program should
    # be sufficient.
    assert dbh.connection == c
    print "Successfully set up a database handle"
if __name__ == "__main__": main()
```
###Insert a Document Into a Collection
```
""" An example of how to insert a document """
import sys
from datetime import datetime
from pymongo import Connection
from pymongo.errors import ConnectionFailure
def main():
    try:
        c = Connection(host="localhost", port=27017)
    except ConnectionFailure, e:
        sys.stderr.write("Could not connect to MongoDB: %s" % e)
        sys.exit(1)
    dbh = c["mydb"]
    assert dbh.connection == c
    user_doc = {
        "username" : "janedoe",
        "firstname" : "Jane",
        "surname" : "Doe",
        "dateofbirth" : datetime(1974, 4, 12),
        "email" : "janedoe74@example.com",
        "score" : 0
    }
    dbh.users.insert(user_doc, safe=True)
    print "Successfully inserted document: %s" % user_doc
if __name__ == "__main__": main()
```
safe=True ensures that your write  
will succeed or an exception will be thrown  
dbh.users.insert(user_doc, safe=True)  
  
w=2 means the write will not succeed until it has  
 been written to at least 2 servers in a replica set.  
dbh.users.insert(user_doc, w=2)

###Query Language
#####Retrieve single document
```
user_doc = dbh.users.find_one({"username" : "janedoe"})
print user_doc
if not user_doc:
  print "no document found for username janedoe"
```
#####Retrieve all documents
```
users = dbh.users.find({"username" : "janedoe"})
if not users:
  print "no document found for username janedoe"
else:
  for user in users:
    print user.get("email")
```
#####Retrieve a subset of properties from each document
```
users = dbh.users.find({"firstname":"jane"}, {"email":1})
for user in users:
  print user.get("email")
```
#####Count
```
userscount = dbh.users.find().count()
print "There are %d documents in users collection" % userscount
/*--or--*/
db.users.count({'name.first':'John'});
```
#####Sort
```
import pymongo
###
users = dbh.users.find().sort("dateofbirth", pymongo.DESCENDING)
for user in users:
  print user.get("email")
```
#####Limit
```
users = dbh.users.find().sort("score", pymongo.DESCENDING).limit(10)
for user in users:
  print user.get("username"), user.get("score", 0)
```
#####Skip
```
users = dbh.users.find().sort("username",pymongo.DESCENDING).limit(2).skip(1)
for user in users:
  print user.get("username")
```
#####Get rid of duplicates
```
for user in dbh.users.find(snapshot=True):
```
###Updating Documents
```
import copy
# first query to get a copy of the current document
old_user_doc = dbh.users.find_one({"username":"janedoe"})
new_user_doc = copy.deepcopy(old_user_doc)
# modify the copy to change the email address
new_user_doc["email"] = "janedoe74@example3.com"
# run the update query
# replace the matched document with the contents of new_user_doc
dbh.users.update({"username":"janedoe"}, new_user_doc, safe=True)
```
#####Update Modifiers
```
dbh.users.update({"username":"janedoe"},
  {"$set":{"email":"janedoe74@example2.com"}}, safe=True)
# For multiple properties
dbh.users.update({"username":"janedoe"}, {"$set":{"email":"janedoe74@example2.com", "score":1}}, safe=True)
```
In order to have your update query write multiple documents, you must pass the “multi=True” parameter to the update method.  
```
dbh.users.update({"score":0},{"$set":{"flagged":True}}, multi=True, safe=True)
```
###Deleting Documents
```
dbh.users.remove({"score":1}, safe=True)
# Delete all documents in user collection dbh.users.remove(None, safe=True)
```
###Common operations on sub-documents embedded in a list
#####$pull
```
# Atomically remove an email address from a user document race-free using the # $pull update modifier
user_doc = {
  "username":"foouser",
  "emails":[
    { 
      "email":"foouser1@example.com",
      "primary":True
    },{
      "email":"foouser2@example2.com",
      "primary":False
    },{
      "email":"foouser3@example3.com",
      "primary":False
    }
  ]
}
# Insert the user document
dbh.users.insert(user_doc, safe=True)
# Use $pull to atomically remove the "foouser2@example2.com" email sub-document
dbh.users.update({"username":"foouser"},
  {"$pull":{"emails":{"email":"foouser2@example2.com"}}}, safe=True)
```
#####$ne
```
# Use $pull to atomically remove all email sub-documents with primary not equal to True
dbh.users.update({"username":"foouser"},
  {"$pull":{"emails":{"primary":{"$ne":True}}}, safe=True)
```
#####$push
```
# Use $push to atomically append a new email sub-document to the user document
new_email = {"email":"fooemail4@exmaple4.com", "primary":False}
dbh.users.update({"username":"foouser"},
  {"$push":{"emails":new_email}}, safe=True)
```
#####Positional operator
```
# Demonstrate usage of the positional operator ($) to modify
# matched sub-documents in-place.
user_doc = {
  "username":"foouser",
  "emails":[
    {
      "email":"foouser1@example.com",
      "primary":True
    },{
      "email":"foouser2@example2.com",
      "primary":False
    },{ 
      "email":"foouser3@example3.com",
      "primary":False
    }
  ]
}
# Insert the user document
dbh.users.insert(user_doc, safe=True)

# Now make the "foouser2@example2.com" email address primrary
dbh.users.update({"emails.email":"foouser2@example2.com"},
  {"$set":{"emails.$.primary":True}}, safe=True)
# Now make the "foouser1@example.com" email address not primary
dbh.users.update({"emails.email":"foouser1@example.com"},
  {"$set":{"emails.$.primary":False}}, safe=True)
```
###MONGO EXPORT
```
mongoexport -d mydb -c users --out mydb.json
```
###BINARY BACKUP
```
mongodump
###
mongorestore -d mydb ./dump/mydb
###Convert to JSON
bsondump dump/mydb/users.bson > users.json
```
###MONGOSTAT
```
mongostat
```
##MONGO COMMANDS (JAVASCRIPT)
```
###SHOW AVAILABLE DATABASES
show dbs

###CONNECT TO A DATABASE OR CREATE
use databasename 
db = databasename

###TO SHOW A COLLECTION
db.collectionName

###COUNT ELEMENTS ON A COLLECTION

db.collectionName.count()

###STORE DOCUMENTS ON A COLLECTION
db.collectionName.insert({title:"Document Title", url:"http://...", tags:["kapow","PWOF"], saved_on:new Date()});

#OR

var doc = {};
doc.title = "NEW DOC TITLE";
doc.url = "http://...";
doc.tags =["KIAP","KABOOM"];
doc.saved_on = new Date();
doc.meta = {};
doc.meta.browser ="Chrome";
doc.meta.OS = "Mac OS";

db.links.save(doc); <----###if it already exists update(doc) else insert(doc)

###QUERYING
db.links.find();

###PRINT DOCUMENTS FORMATED
db.links.find().forEach(printjson);
```
###_id  ObjectID( )
```
db.users.find()[1]._id.getTimestamp()

### SET NEW ID
function counter(name) {
  var ret = db.counters.findAndModify({query:{_id:name}, update:{$inc : {next:1}}, "new":true, upsert:true);
  return ret.next;
}
db.products.insert({_id: counter("products"), name: "product 1"});
db.products.insert({_id: counter("products"), name: "product 2"});

```
###Relations
```
db.users.insert({ name: "Andrew"});
var a = db.users.findOne({name:"Andrew"});
db.links.insert({title:"JEWTUBE",url:"http://www.youtube.com", userId: a._id});

```
###Query Syntax & Operators
#####SELECT
```
db.users.drop();

db.users.find();  <== returns cursorObject

db.users.findOne({'firstname':'John'}); <==returns a single Document

db.users.findOne({'name':'John'}).name;
```
#####LIMIT
```
db.links.find({favourites:100},{ title: 1, url: true}); <== select fields to retrieve

db.links.find({favourites:100},{ title: 0, url: false}); <== exclude fields

db.links.find({favourites:100},{title:1,url:1, _id:0});
```
#####NESTING
```
db.users.find({'name.first':'John'});

db.users.findOne({'name.first':'John'},{'name.last':1});
```
#####GREATER THAN Operator
```
db.links.find({favourites:{$gt:50}});
```
#####LESS THAN Operator
```
db.links.find({favourites:{$lt:50}});
```
#####LESS THAN OR EQUAL TO Operator
```
db.links.find({favourites:{$lte:50}});
```
#####GREATER THAN OR EQUAL TO Operator
```
db.links.find({favourites:{$gte:50}});
```
OPERATORS WORKING SIMULTANEUSLY
```
db.links.find({favourites:{$gt:50, $lt:300}});
```
#####NOT EQUAL Operator
```
db.links.find({'name':{$ne:'John'}});
```
#####OR Operator
```
db.links.find({$or: [{'name.first':'John'},{'name.last':'Wilson'}]});
```
#####NOR (NOT OR) Operator
```
db.links.find({$nor: [{'name.first':'John'},{'name.last':'Wilson'}]});
```
#####AND Operator
```
db.users.find({ $and:[{'name.first':'John'},{'name.last':'Jones'}]});
```
#####EXISTS Operator
```
db.users.find({email: {$exists:true}});
```
#####MOD Operator
```
db.links.find({favourites: {$mod:[5,0]}});
```
#####NOT Operator
```
db.links.find({favourites: {$not: { $mod: [5,0] }}});
```
#####ELEMENT MATCH OPERATOR  
Searches inside Arrays
```
db.users.find({logins:{ $elemMatch: {minutes:20 }}});
```
#####WHERE Operator
```
db.users.find({$where: 'this.name.first === "John"',age:30});
```
#####MERGE DUPLICATES
```
db.link.distinct('favourites');
```
#####GROUP Documents
```
db.links.group({ 
  key: { userID:true },
  initial: { favCount: 0 },
  reduce: function (doc, o){
    o.favCount += doc.favourites;
  },
  finalize: function (o){
    o.name = db.users.findOne({_id: o.userId}).name;
  }
});

```
#####REGEX INSIDE QUERIES
```
db.links.find({title: /tuts\+$/});
```
#####REGEX Operator  
Allows you to group with other operators
```
db.links.find({ title:{ $regex: /tuts\+$/, $ne:'Mobiletuts'} });
```
#####Sort
```
db.links.find({title:1,_id:0}).sort({title: 1}); /*ASCENDING ORDER*/

db.links.find({title:1,_id:0}).sort({title: -1}); /*DESCENDING ORDER*/

db.links.find({},{title:1,favourites: 1, _id:0}).sort({favourites:-1, title:1});
```
#####Limit
```
db.links.find({},title:1,favourites:1,_id:0).sort({favourites:1}).limit(1);
```
#####Skip
```
db.links.find().skip(0*3).limit(3); /*GETS ELEMENTS 1,2 & 3*/
db.links.find().skip(1*3).limit(3); /*GETS ELEMENTS 4,5 & 6*/
```
###Updating Documents
####Update Method
#####Update By Replacement  
Replace whatever record it finds that matches the first object.
All other fields are removed and replaced with the second object values.
```
db.users.update({'name.first':'John'},{'job':'developer'});

/*UPSERT*/

/*Use this if you want to create a document if it doesn't find the one you passed to update*/

db.users.update({name: 'Kate Wills'},{name: 'Kate Wills', job:'LISP Developer}, true);
```
#####Update By Modification
```
/*INCREMENT*/

var n = {title: 'Nettuts+'};
db.links.find(n,{title:1, favourites:1});
db.links.update(n,{$inc:{favourites: 5});
db.links.update(n,{$inc:{favourites: -5});

/*CHANGE VALUE*/

var q = {name: "Kate Wills};
db.users.update(q,{$set: {job: 'Wev Developer'}});

/*This also works with fields that doesn't exist yet, and to get rid of fields*/

db.users.update(q,{$unset: {job: 'Wev Developer'}});
```
#####Update Multiple Records  
This just works with updates by modification.
```
sadf
```