Getting Started with MongoDB Atlas: Cloud Based Database Management in Python
Introduction
Atlas is a cloud-based database service provided by MongoDB, a popular NoSQL database management system. Atlas provides fully managed MongoDB instances, allowing users to easily create, configure, and scale their databases in the cloud. Atlas provides features such as automated backups, monitoring, and alerts, making it a popular choice for developers and organizations looking for a reliable and scalable database solution. Additionally, Atlas provides an intuitive web interface and a comprehensive API, allowing users to manage their databases programmatically.
Make database and add documents by python
To create a database and add documents using Python, you can use the pymongo library, which is the official Python driver for MongoDB. Here's an example code snippet that demonstrates how to create a database, add documents to it, and query the documents:
python code
import pymongo
# Connect to the MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Create a database
db = client["mydatabase"]
# Create a collection (similar to a table in SQL)
col = db["customers"]
# Add documents to the collection
customer1 = {"name": "John", "address": "Highway 37"}
customer2 = {"name": "Peter", "address": "Lowstreet 27"}
customer3 = {"name": "Amy", "address": "Apple st 652"}
col.insert_many([customer1, customer2, customer3])
# Query the documents in the collection
for customer in col.find():
print(customer)
In this example, we first connect to the MongoDB server running on the local machine. Then, we create a new database called "mydatabase". Next, we create a new collection called "customers" and add three documents to it using the insert_many method. Finally, we query all the documents in the collection using the find method and print them to the console.
Steps for Make database and add documents by python
To create a database, you can simply call the MongoClient constructor with the connection string for your MongoDB server and the name of the database you want to create. Here's an example:
python code
import pymongo
# Connect to the MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Create a database
db = client["mydatabase"]
To create a collection (similar to a table in SQL), you can call the create_collection method on your database object. Here's an example:
python code
# Create a collection
col = db.create_collection("customers")
Alternatively, you can create a collection by simply adding documents to it using the insert_one or insert_many methods. If the collection doesn't already exist, it will be created automatically. Here's an example:
python code
# Add documents to the collection
customer1 = {"name": "John", "address": "Highway 37"}
customer2 = {"name": "Peter", "address": "Lowstreet 27"}
customer3 = {"name": "Amy", "address": "Apple st 652"}
col.insert_many([customer1, customer2, customer3])
To query documents in a collection, you can use the find method on the collection object. This method returns a cursor that you can iterate over to access the documents. Here's an example:
python code
# Query the documents in the collection
for customer in col.find():
print(customer)
You can also use query filters to retrieve specific documents. For example, to retrieve all customers with the name "John", you can do the following:
python code
# Query documents with a filter
query = {"name": "John"}
result = col.find(query)
for customer in result:
print(customer)
Finally, to delete documents from a collection, you can use the delete_one or delete_many methods. Here's an example:
python code
# Delete a document from the collection
query = {"name": "John"}
col.delete_one(query)
# Delete all documents from the collection
col.delete_many({})
Query Filters with Conditions in MongoDB
You can use a variety of query operators to specify conditions when querying documents in MongoDB. Here are some common operators and how to use them in Python with pymongo:
1. $eq: Matches values that are equal to a specified value.
python code
# Query documents where the "name" field is equal to "John"
query = {"name": {"$eq": "John"}}
result = col.find(query)
2. $ne: Matches values that are not equal to a specified value.
python code
# Query documents where the "name" field is not equal to "John"
query = {"name": {"$ne": "John"}}
result = col.find(query)
3. $gt: Matches values that are greater than a specified value.
python code
# Query documents where the "age" field is greater than 30
query = {"age": {"$gt": 30}}
result = col.find(query)
4. $gte: Matches values that are greater than or equal to a specified value.
python code
# Query documents where the "age" field is greater than or equal to 30
query = {"age": {"$gte": 30}}
result = col.find(query)
5. $lt: Matches values that are less than a specified value.
python code
# Query documents where the "age" field is less than 30
query = {"age": {"$lt": 30}}
result = col.find(query)
6. $lte: Matches values that are less than or equal to a specified value.
python code
# Query documents where the "age" field is less than or equal to 30
query = {"age": {"$lte": 30}}
result = col.find(query)
7. $in: Matches any of the values specified in an array.
python code
# Query documents where the "name" field is either "John" or "Peter"
query = {"name": {"$in": ["John", "Peter"]}}
result = col.find(query)
8. $nin: Matches none of the values specified in an array.
python code
# Query documents where the "name" field is neither "John" nor "Peter"
query = {"name": {"$nin": ["John", "Peter"]}}
result = col.find(query)
These are just a few examples of the query operators available in MongoDB. You can find a full list of operators and their usage in the MongoDB documentation.
Update documents in a MongoDB
To update documents in a MongoDB collection using Python and pymongo, you can use the update_one or update_many methods on the collection object. Here are some examples:
Update a single document:
python code
# Update a document where the "name" field is "John"
query = {"name": "John"}
new_values = {"$set": {"address": "123 Main St"}}
col.update_one(query, new_values)
This will update the first document in the collection where the "name" field is "John" and set its "address" field to "123 Main St".
Update multiple documents:
python code
# Update all documents where the "name" field is "John"
query = {"name": "John"}
new_values = {"$set": {"address": "123 Main St"}}
col.update_many(query, new_values)
This will update all documents in the collection where the "name" field is "John" and set their "address" field to "123 Main St".
Note that in both examples, we're using the $set operator to update the value of the "address" field. This operator is used to update specific fields in a document without overwriting the entire document.
You can also use other update operators to perform more complex updates, such as $inc to increment a field value or $push to add an element to an array field. Here are some examples:
Increment a field value:
python code
# Increment the "views" field by 1 for a document where the "title" field is "My Blog Post"
query = {"title": "My Blog Post"}
new_values = {"$inc": {"views": 1}}
col.update_one(query, new_values)
Add an element to an array field:
python code
# Add a new tag to the "tags" array for a document where the "title" field is "My Blog Post"
query = {"title": "My Blog Post"}
new_values = {"$push": {"tags": "mongodb"}}
col.update_one(query, new_values)
These are just a few examples of how to update documents in a MongoDB collection using Python and pymongo. You can find more information and examples in the pymongo documentation.
Access a collection in MongoDB using PyMongo in Python
To access a collection in MongoDB using PyMongo in Python, you need to follow these basic steps:
python code
import pymongo
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
col = db["mycollection"]
Here, mycollection is the name of the collection you want to access.
Now, you can use the col object to perform various operations on the collection, such as inserting documents, querying documents, and updating documents.
Here's an example that shows how to access a collection named users in a database named mydatabase:
python code
import pymongo
# Connect to the MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Access the "mydatabase" database
db = client["mydatabase"]
# Access the "users" collection
col = db["users"]
This will give you access to the users collection in the mydatabase database, and you can start performing operations on it using the col object.
Query documents from a collection in MongoDB using PyMongo in Python
To query documents from a collection in MongoDB using PyMongo in Python, you need to use the find method on the collection object. The find method returns a cursor object, which you can iterate over to access the matching documents.
Here are some basic examples of querying documents from a collection using PyMongo:
Query all documents in a collection:
python code
import pymongo
# Connect to the MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Access the "mydatabase" database
db = client["mydatabase"]
# Access the "users" collection
col = db["users"]
# Query all documents in the "users" collection
cursor = col.find()
# Iterate over the cursor to access the documents
for doc in cursor:
print(doc)
This will print all documents in the users collection.
Query documents that match a specific condition:
python code
# Query documents where the "name" field is "John"
query = {"name": "John"}
cursor = col.find(query)
# Iterate over the cursor to access the documents
for doc in cursor:
print(doc)
This will print all documents in the users collection where the name field is John.
Query documents and retrieve only specific fields:
python code
# Query all documents and retrieve only the "name" and "age" fields
projection = {"name": 1, "age": 1}
cursor = col.find({}, projection)
# Iterate over the cursor to access the documents
for doc in cursor:
print(doc)
This will print all documents in the users collection, but only the name and age fields will be retrieved.
Query documents and sort the results:
python code
# Query documents and sort the results by the "age" field in descending order
query = {"name": "John"}
sort = [("age", pymongo.DESCENDING)]
cursor = col.find(query).sort(sort)
# Iterate over the cursor to access the documents
for doc in cursor:
print(doc)
This will print all documents in the users collection where the name field is John, sorted by the age field in descending order.
What is the default storage engine for MongoDB?
The default storage engine for MongoDB was previously MMAPv1, which used memory-mapped files to manage data storage. However, starting from version 4.2, the default storage engine for MongoDB is WiredTiger.
WiredTiger is an advanced storage engine that is designed to provide better performance and scalability compared to MMAPv1. It uses a combination of in-memory and on-disk storage to optimize data access and reduce disk I/O operations. WiredTiger also supports advanced features such as compression, encryption, and document-level locking.
While WiredTiger is the default storage engine for MongoDB, you can still use other storage engines such as MMAPv1, RocksDB, and In-Memory storage. The choice of storage engine depends on your specific use case and performance requirements.
Frequently Aksed Questions
Q1. What is MongoDB? Explain non-relational databases. In which scenarios it is preferred to use MongoDB over SQL databases?
MongoDB is a NoSQL document-oriented database that is designed for high scalability, performance, and flexibility. It is an open-source database that stores data in a flexible, JSON-like document format that allows for easy retrieval and manipulation of data.
Non-relational databases, also known as NoSQL databases, are databases that do not use the traditional relational model used by SQL databases. Instead, NoSQL databases use various data models such as document-based, key-value, graph-based, and column-family models to store and manage data. NoSQL databases are designed to handle large volumes of unstructured and semi-structured data, and they are highly scalable and flexible.
In scenarios where the data is unstructured, semi-structured, or highly variable, NoSQL databases such as MongoDB are preferred over SQL databases. MongoDB is suitable for scenarios where the data structure is not fixed and may change over time, and when the data requires high read and write throughput with low latency. It is also preferred in cases where data needs to be distributed across multiple nodes or in a cluster, as MongoDB is designed to scale horizontally by adding more nodes to the cluster.
Here are some scenarios where MongoDB is preferred over SQL databases:
1. Web applications that require high read and write throughput: MongoDB is designed to handle high volumes of reads and writes with low latency, making it an ideal choice for web applications that require high performance.
2. Big Data and Analytics: MongoDB's flexible document model and scalability make it an ideal choice for storing and analyzing big data.
3. Mobile applications: MongoDB's mobile database, Realm, is designed to work seamlessly with mobile devices, making it an ideal choice for mobile applications.
4. Internet of Things (IoT): MongoDB's flexible document model and scalability make it an ideal choice for storing and analyzing data generated by IoT devices.
MongoDB is a NoSQL document-oriented database that is preferred over SQL databases in scenarios where the data is unstructured, semi-structured, or highly variable, and where high read and write throughput with low latency is required. It is also preferred in cases where data needs to be distributed across multiple nodes or in a cluster.
Q2. State and Explain the features of MongoDB. point by point
MongoDB is a popular NoSQL document-oriented database that offers several features that make it a powerful and flexible choice for managing data. Here are some of the key features of MongoDB:
1. Document-oriented: MongoDB stores data in a flexible, JSON-like document format that allows for easy retrieval and manipulation of data.
2. Scalability: MongoDB is designed to scale horizontally by adding more nodes to a cluster, allowing for high availability and reliability.
3. Indexing: MongoDB supports multiple indexing options that help to optimize queries and improve performance.
4. Querying: MongoDB offers a rich query language that supports a wide range of query operations and provides powerful aggregation and data processing capabilities.
5. Aggregation: MongoDB offers a powerful aggregation framework that allows for complex data processing and analysis.
6. Sharding: MongoDB offers built-in support for sharding, which allows for distributing data across multiple nodes and handling large volumes of data.
7. Replication: MongoDB offers built-in replication, which allows for creating multiple copies of data across multiple nodes to ensure high availability and data durability.
8. Ad-hoc queries: MongoDB allows for ad-hoc queries, meaning that queries can be performed on any field without the need for pre-defined schema or structure.
9. Schemaless: MongoDB is schemaless, meaning that there is no pre-defined schema or structure, allowing for flexibility and ease of use.
MongoDB is a powerful and flexible NoSQL document-oriented database that offers several features such as scalability, indexing, powerful querying and aggregation capabilities, sharding, replication, ad-hoc queries, and schemaless architecture. These features make MongoDB a popular choice for managing data in a variety of scenarios, such as web applications, big data and analytics, mobile applications, and the Internet of Things.
Q3. Write a code to connect MongoDB to Python. Also, create a database and a collection in MongoDB.
Certainly! Here's an example code to connect to MongoDB using PyMongo and create a database and a collection:
python code
import pymongo
# Connect to MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Create a database
mydb = client["mydatabase"]
# Create a collection
mycol = mydb["customers"]
In the code above, we first import the pymongo module, which provides the tools needed to work with MongoDB in Python.
Next, we connect to the MongoDB server running on localhost using the default port 27017 by creating a MongoClient object.
Then, we create a new database named mydatabase using the client object by calling the client["mydatabase"] method.
Finally, we create a new collection named customers in the mydatabase database using the mydb["customers"] method.
Note that the database and collection are not actually created until the first document is inserted into the collection.
Q4. Explain how you can use the find() method to query the MongoDB database. Write a simple code to demonstrate this.
The find() method is used to query the MongoDB database and retrieve data from a collection. The find() method takes an optional query parameter, which is a document that specifies the selection criteria for the query. Here's an example code to demonstrate the use of the find() method:
python code
import pymongo
# Connect to MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Select database and collection
mydb = client["mydatabase"]
mycol = mydb["customers"]
# Find all documents in the collection
for x in mycol.find():
print(x)
# Find documents where the address starts with the letter 'S'
query = { "address": { "$regex": "^S" } }
results = mycol.find(query)
for result in results:
print(result)
In the code above, we first connect to the MongoDB server and select a database and a collection.
We then call the find() method on the collection object to retrieve all the documents in the collection. The find() method returns a cursor object, which we can iterate over to retrieve the documents.
Next, we create a query document that specifies a regular expression to match documents where the address field starts with the letter 'S'. We pass this query document as a parameter to the find() method to retrieve the matching documents. Finally, we iterate over the results and print each document.
The query parameter can be any valid MongoDB query document, which allows for powerful querying capabilities.
Q5. Explain why delete_one(), delete_many(), and drop() is used.
In MongoDB, there are different methods for deleting data, each serving a specific purpose:
1. delete_one(): This method is used to delete a single document that matches a specified filter. If there are multiple documents that match the filter, only the first one will be deleted.
2. delete_many(): This method is used to delete all the documents that match a specified filter.
3. drop(): This method is used to drop an entire collection, including all its documents.
Here are some scenarios where each method might be used:
• delete_one(): Let's say we have a collection of customer orders, and we want to delete a single order that was placed in error. We can use delete_one() to remove that specific order from the collection.
• delete_many(): Let's say we have a collection of customer reviews, and we want to delete all the reviews that were submitted by a particular user who violated the website's terms of service. We can use delete_many() to remove all the reviews submitted by that user from the collection.
• drop(): Let's say we have a collection of user login information, and we want to delete the entire collection because we are no longer using that data. We can use drop() to delete the entire collection and all its documents.
delete_one() and delete_many() both require a filter to specify which documents to delete, while drop() deletes the entire collection without any filters. It's important to use these methods carefully and double-check that the correct documents or collection are being deleted.
Example
Sure, here's an example code that demonstrates the use of delete_one(), delete_many(), and drop() methods:
python code
import pymongo
# Connect to MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Select database and collection
mydb = client["mydatabase"]
mycol = mydb["customers"]
# Delete a single document
myquery = { "name": "John" }
mycol.delete_one(myquery)
# Delete multiple documents
myquery = { "age": { "$gt": 30 } }
result = mycol.delete_many(myquery)
print(result.deleted_count, " documents deleted.")
# Drop the entire collection
mycol.drop()
In the code above, we first connect to the MongoDB server and select a database and a collection.
We then call delete_one() method to delete a single document that matches the filter { "name": "John" }. This will delete the first document that matches this filter.
Next, we call delete_many() method to delete all the documents that match the filter { "age": { "$gt": 30 } }. This will delete all the documents where the "age" field is greater than 30.
Finally, we call drop() method to drop the entire "customers" collection. This will delete all the documents in the collection and the collection itself.
Q6. how to set _id small number in insert_many
In MongoDB, the _id field is a unique identifier for each document in a collection. By default, if you do not specify an _id field when inserting a document, MongoDB will create a unique identifier for you.
However, if you want to specify your own _id values, you can do so by including the _id field in the document. To insert multiple documents with specific _id values using the insert_many() method in PyMongo, you can create a list of dictionaries, where each dictionary represents a document with a specific _id value.
Here's an example code that demonstrates how to insert multiple documents with specific _id values using insert_many():
python code
import pymongo
# Connect to MongoDB server
client = pymongo.MongoClient("mongodb://localhost:27017/")
# Select database and collection
mydb = client["mydatabase"]
mycol = mydb["mycollection"]
# Create a list of dictionaries, where each dictionary represents a document with a specific _id value
mydocs = [
{ "_id": 1, "name": "John", "age": 28 },
{ "_id": 2, "name": "Jane", "age": 32 },
{ "_id": 3, "name": "Mike", "age": 35 },
