Pymongo - mongo in python¶

To use python with mongo we need to use the pymongo package

• install using pip install pymongo, or via the anaconda application

Connecting¶

To connect to our Database we need to instantiate a client connection. To do this wee need:

• hostname or ip-address
• port
• username
• password

In addition we may sometimes need to provide an authSource. This simply tells Mongo where the information on our user exists.

*NOTE: NEVER hard encode your password!!!*

Verify the connection is working:

Accessing Databases and Collections¶

Even if we have authenticated oursevles, we still need to tell Mongo what database and collections we are interested. Once connected those attributes are name addressable:

• conn['database_name'] or conn.database_name
• database['coll_name'] or database.coll_name

Connecting to the Database:

Proof we're connected:

Connecting to the Collections:

Proof this works:

Querying¶

Once connected, we are ready to start querying the database.

The great thing about Python is it's integration with both JSON and Mongo, meaning that the Python Mongo API is almost exactly the same as Monog's own query API.

find_one()¶

This method works exactly the same as the Mongo equivelant. In addition the interior logic is a direct 1-to-1 with Mongo's

In Class Excercise:¶

Using the twitter_favorites collection, find a singular status with a tesla hashtag

find()¶

Likewise pymongo's find() works exactly like mongo's console find() command. One thing to note find({}) returns a cursor (iterable), not an actual document.

In Class Questions:

1. What is the advantage to using a generator/iterable in this instance?
2. What is the benefit of being able to query for one document find_one() vs a list of documents find()?

Iterating Through Our Cursor¶

We can prove the query executed correctly by iterating through all of the documents

Instead of iterating through the documents, we can also extract all of the documents at once by calling list(docs). This approach though comes with some drawbacks.

• The code will have to wait for all of the records to be pulled (unless threaded)
• You'll need to ensure that you have the memory to store all of the results
• Any connection errors will reset the process
• etc.

In Class Excercise:¶

Using the twitter_statuses collection, calculate the total number of favorites that elonmusk has received

Would we get the same result if we ran this processes against the twitter_favorites collection?

Exception to the Rule¶

While pymongo's pattern system effectively parallels the mongo shell, there is one key exception:

• The use of the $

In mongo shell the following is valid:

• db.coll_name.find({"attr": {$exists: true}})

However, in pymongo this would be phrased as:

• db.coll_name.find({"attr": {"$exists": True}})

Since $ isn't a valid value in python, these functions need to be wrapped as strings.

In Class Excercise:¶

Using a mixture of mongo queries and python, determine if the person who has the most favorited tweet (*favorites collection*) in 2021 is a friend of Elon Musks (screen_name - 'elonmusk').

Note: Sorting with pymongo is slightly different - .sort([("field1", 1), ("field2", -1)])

insert_one() and insert_many()¶

These methods enable us to insert one or more documents into the collection

Do not run the following sections!

Question: Will the following cell cause an error?

We can insert any valid object by simply calling:

• coll_name.insert_one(doc)

Note: If we do not provide a _id field in the document mongo will automatically create one. This means that there is nothing stopping us from inserting duplicate records

We can verify on the python side by querying for the record

We can also insert many documents at once:

• coll_name.insert_many(docs)
• where docs is a list of valid BSON documents

Verification:

update_one() and update_many()¶

As discussed in the slides, these methods are used to modify an existing record.

While they are a bit more complexed than the other methods, I did want to provide a little example.

coll_name.update_one(find_pattern, update_pattern)

1. We find the documnet(s) that match the find_pattern

• The find_pattern follows the same structure as the mongo shell and pymongo find methods

2. We dictate the update pattern for the identified document(s)

Works the same way for coll_name.update_many(find_pattern, update_pattern)

delete_one() and delete_many()¶

Deleting records works almost the same was as updating, except we only provide a find_pattern to the method.

coll_name.delete_one(find_pattern)

Now we shouldn't be able to find that document:

We can also inspect the DeleteResult from the command:

Small example using coll_name.delete_many()

In Class Excercise:¶

1. Insert a JSON document into the test_collection with the following structure:

{
       "name": `your_name`,
       "favorite_movie": `movie_name`,
       "favorite_bands": [
           `band_name_1`,
           `band_name_2`,
           `etc.`
       ]
   }

2. Review the response object and execute a query in python to prove your document has sucessfully been inserted
3. Using python, delete your object and verify the results by reviewing the response object and querying the collection.