Page Title

Tutorial 1

Working with MongoDB

Introduction

MongoDB is an open-source document database and leading NoSQL database.

MongoDB stores data in JSON-like documents, which makes the database very flexible and scalable.

Python needs a MongoDB driver to access the MongoDB database.

To work with MongoDB first you need to install PyMongo

You can use PIP to install "PyMongo".

Download and install "PyMongo":

C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>python -m pip install pymongo

In the Python shell, the following should run without raising an exception:

>>> import pymongo

If the above code was executed with no errors, "pymongo" is installed and ready to be used.

Making a Connection with Mongo Client

The first step when working with PyMongo is to create a MongoClient to the running mongod instance. Doing so is easy:

>>> from pymongo import MongoClient
>>> client = MongoClient()

The above code will connect on the default host and port. We can also specify the host and port explicitly, as follows:

>>> client = MongoClient('localhost', 27017)

Or use the MongoDB URI format:

>>> client = MongoClient('mongodb://localhost:27017/')

Getting a Database

A single instance of MongoDB can support multiple independent databases. When working with PyMongo you access databases using attribute style access on MongoClient instances:

>>> db = client.post_database

If your database name is such that using attribute style access won’t work (like post-database), you can use dictionary style access instead:

>>> db = client['post-database']

You can check if a database exist by listing all databases in you system:

print(client.list_database_names())

Or you can check a specific database by name:

dblist = client.list_database_names()
if "mydatabase" in dblist:
print("The database exists.")

Getting a Collection

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:

>>> collection = db.post_collection

or (using dictionary style access):

>>>collection = db['post-collection']]

An important note about collections (and databases) in MongoDB is that they are created lazily - none of the above commands have actually performed any operations on the MongoDB server.

Collections and databases are created when the first document is inserted into them.

Documents

Data in MongoDB is represented (and stored) using JSON-style documents. In PyMongo we use dictionaries to represent documents. As an example, the following dictionary might be used to represent a blog post:

>>> import datetime

>>> post = {"author": "AJ",
...    "text": "My first blog post!",
...    "tags": ["mongodb", "python", "pymongo"],
...    "date": datetime.datetime.utcnow()}

Note that documents can contain native Python types (like datetime.datetime instances) which will be automatically converted to and from the appropriate BSON types.

Inserting a Document

To insert a document into a collection we can use the insert_one() method:

When a document is inserted a special key, "_id", is automatically added if the document doesn’t already contain an "_id" key. The value of "_id" must be unique across the collection. insert_one() returns an instance of InsertOneResult.

After inserting the first document, the posts collection has actually been created on the server. We can verify this by listing all of the collections in our database:

>>> db.list_collection_names()
[u'posts']

Bulk Inserts

To insert many document, we can also perform bulk insert operations, by passing a list as the first argument to insert_many() method:

>>> import pymongo
>>> from pymongo import MongoClient

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

>>> new_posts = [{"author": "AJ",
...    "text": "My first blog post!",
...    "tags": ["mongodb", "python"],
...    "date": datetime.datetime.utcnow()},
...    {"author": "Anant",
...    "text": "My first blog post!",
...    "title": "MongoDB is fun",
...    "date": datetime.datetime.utcnow()} ]

>>> result = posts.insert_many(new_posts)
>>> result.inserted_ids
[ObjectId('...'), ObjectId('...')]

Note : MongoDB is schema-free

MongoDB is a JSON-style data store. The documents stored in the database can have varying sets of fields, with different types for each field.

In the above example new_posts[1] has a different "shape" than the other posts - there is no "tags" field and we have added a new field, "title". This is why MongoDB is schema-free.

Getting a Single Document With find_one()

The most basic type of query that can be performed in MongoDB is find_one(). This method returns a single document matching a query (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. Here we use find_one() to get the first document from the posts collection:

>>> import pymongo
>>> from pymongo import MongoClient

>>> import pprint

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

>>> pprint.pprint(posts.find_one())

Result:

{u'_id': ObjectId('...'),
u'author': u'AJ',
u'date': datetime.datetime(...),
u'tags': [u'mongodb', u'python', u'pymongo'],
u'text': u'My first blog post!'}

The result is a dictionary matching the one that we inserted previously.

The returned document contains an "_id", which was automatically added on insert.

find_one() also supports querying on specific elements that the resulting document must match. To limit our results to a document with author "AJ" we do:

>>> import pymongo
>>> from pymongo import MongoClient

>>> import pprint

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

>>> pprint.pprint(posts.find_one({"author": "AJ"}))

Result:

{u'_id': ObjectId('...'),
u'author': u'AJ',
u'date': datetime.datetime(...),
u'tags': [u'mongodb', u'python', u'pymongo'],
u'text': u'My first blog post!'}

If we try with a different author, like "Anant", we’ll get no result:

>>> posts.find_one({"author": "Anant"})
>>>

Querying By ObjectId

We can also find a post by its _id, which in example is an ObjectId:

>>> import pymongo
>>> from pymongo import MongoClient

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

>>> post_id
ObjectId(...)

>>> pprint.pprint(posts.find_one({"_id": post_id}))

Result:

{u'_id': ObjectId('...'),
u'author': u'AJ',
u'date': datetime.datetime(...),
u'tags': [u'mongodb', u'python', u'pymongo'],
u'text': u'My first blog post!'}

Note that an ObjectId is not the same as its string representation:

>>> post_id_as_str = str(post_id)
>>> posts.find_one({"_id": post_id_as_str}) # No result

Find All

To select data from a table in MongoDB, we can also use the find() method.

The find() method returns all occurrences in the selection.

The first parameter of the find() method is a query object. In this example we use an empty query object, which selects all documents in the collection.

>>> import pymongo
>>> from pymongo import MongoClient

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

for x in posts.find():
print(x)

Delete Document

To delete one document, we use the delete_one() method.

The first parameter of the delete_one() method is a query object defining which document to delete.

Delete Collection

You can delete a table, or collection as it is called in MongoDB, by using the drop() method.

>>> import pymongo
>>> from pymongo import MongoClient

>>> client = MongoClient('mongodb://localhost:27017/')
>>> db = client["post_database"]
>>> posts = db["posts"]

>>> posts.drop()

The drop() method returns true if the collection was dropped successfully, and false if the collection does not exist.

Update Document

You can update a record, or document as it is called in MongoDB, by using the update_one() method.

The first parameter of the update_one() method is a query object defining which document to update.

The second parameter is an object defining the new values of the document.

Counting

If we just want to know how many documents match a query we can perform a count_documents() operation instead of a full query. We can get a count of all of the documents in a collection:

>>> posts.count_documents({})

or just of those documents that match a specific query:

Limit the Result

To limit the result in MongoDB, we use the limit() method.

The limit() method takes one parameter, a number defining how many documents to return.

Tutorial 1

Working with MongoDB

Introduction

Making a Connection with Mongo Client

Getting a Database

Getting a Collection

Documents

Inserting a Document

Bulk Inserts

Note : MongoDB is schema-free

Getting a Single Document With find_one()

Result:

Result:

Querying By ObjectId

Result:

Find All

Delete Document

Delete Collection

Update Document

Counting

Limit the Result

The End

Tutorial 1 - Python - Working with MongoDB