MongoDB Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Q1. What is MongoDB? Explain non-relational databases in short. In which scenarios it is preferred to use \n",
    "# # MongoDB over SQL databases?\n",
    "# # Answer :-\n",
    "# MongoDB is a popular document-oriented, NoSQL (non-relational) database management system. It provides a flexible and scalable approach to storing, managing, and retrieving data. Instead of using tables with fixed schemas like in SQL databases, MongoDB stores data in flexible, JSON-like documents with dynamic schemas called BSON (Binary JSON).\n",
    "# Non-relational databases, including MongoDB, differ from SQL databases in several ways:\n",
    "\n",
    "# Schema flexibility: Non-relational databases allow for dynamic and flexible schemas, meaning each record or document can have its own structure and fields. This flexibility is beneficial when dealing with evolving data or when the data has a complex and hierarchical nature.\n",
    "# Horizontal scalability: Non-relational databases are designed to scale horizontally by distributing data across multiple servers or clusters, allowing for high scalability and performance.\n",
    "# Non-structured data: Non-relational databases handle unstructured or semi-structured data efficiently, such as JSON, XML, key-value pairs, graphs, or documents with varying structures.\n",
    "# High availability: Non-relational databases often provide automatic replication and failover mechanisms, ensuring high availability and fault tolerance.\n",
    "# MongoDB is preferred over SQL databases in several scenarios:\n",
    "\n",
    "# Flexible data model: When dealing with data that has a changing or evolving structure, MongoDB's flexible schema allows for easier adaptation and avoids the need for frequent schema modifications.\n",
    "# Scalability: MongoDB excels in horizontally scalable scenarios, where the database needs to handle high read/write loads or large volumes of data. It can distribute data across multiple servers and clusters, providing excellent scalability and performance.\n",
    "# Complex data structures: If your data has a complex, hierarchical structure or contains nested arrays and objects, MongoDB's document model can represent and query such data more naturally compared to SQL databases.\n",
    "# Real-time analytics: MongoDB's features like sharding and replication make it well-suited for real-time analytics, where large amounts of data need to be processed and analyzed in near real-time.\n",
    "# Agile development: MongoDB's flexible schema allows for agile development and faster iterations, as it eliminates the need for costly and time-consuming migrations when modifying the data model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Q2. State and Explain the features of MongoDB.\n",
    "# # Answer :-\n",
    "# MongoDB offers several key features that make it a popular choice for data management:\n",
    "\n",
    "# 1.Flexible Data Model: MongoDB uses a document data model that allows for the storage of data in flexible, JSON-like documents called BSON. This flexibility enables easy and dynamic schema modifications, accommodating evolving data structures.\n",
    "\n",
    "# 2.Scalability and High Performance: MongoDB is designed to scale horizontally across multiple servers or clusters, allowing for high scalability and performance. It distributes data across shards, enabling efficient handling of large volumes of data and high read/write workloads.\n",
    "\n",
    "# 3.Indexing: MongoDB supports various types of indexes, including single-field, compound, geospatial, text, and hashed indexes. Indexing improves query performance and allows for efficient searching and sorting of data.\n",
    "\n",
    "# 4.Ad Hoc Queries: MongoDB provides powerful ad hoc querying capabilities. It supports a rich query language with a wide range of operators, allowing for flexible and complex searches on document fields, arrays, and nested objects.\n",
    "\n",
    "# 5.Aggregation Framework: MongoDB's Aggregation Framework allows for advanced data processing and analysis. It provides operators for grouping, filtering, transforming, and computing data, enabling powerful analytics and reporting capabilities.\n",
    "\n",
    "# 6.Full-text Search: MongoDB includes a built-in full-text search engine that supports text search queries on string fields. It allows for efficient text indexing and search operations, enhancing the search functionality of applications.\n",
    "\n",
    "# 7.Replication and High Availability: MongoDB offers built-in replication features that provide automatic data synchronization and failover. It allows for the creation of replica sets, ensuring data redundancy and high availability in case of server failures.\n",
    "\n",
    "# 8.Automatic Sharding: MongoDB supports automatic data partitioning through sharding. Sharding distributes data across multiple shards, enabling horizontal scalability and efficient distribution of read/write operations.\n",
    "\n",
    "# 9.Geospatial Capabilities: MongoDB includes geospatial indexes and queries, making it suitable for applications that require location-based data processing. It supports various geospatial queries and operations, such as finding nearby locations or calculating distances.\n",
    "\n",
    "# 10.Security: MongoDB offers robust security features, including authentication, role-based access control (RBAC), encryption, and auditing. It allows for fine-grained access control and ensures the confidentiality and integrity of data.\n",
    "\n",
    "# 11.Integration and Ecosystem: MongoDB integrates well with various programming languages and frameworks, providing official drivers for multiple programming languages. It also has a rich ecosystem with a wide range of tools, libraries, and frameworks that enhance development and management capabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Q3. Write a code to connect MongoDB to Python. Also, create a database and a collection in MongoDB.\n",
    "# # Answer :-\n",
    "# 1) Install pymongo module using the following command:\n",
    "# ```python -m pip install pymongo==2.8 --user ```\n",
    "# 2) Import MongoClient from PyMongo library as follows :\n",
    "# `from pymongo import MongoClient`\n",
    "# 3) Create an instance of `MongoClient()` by passing your server URL or IP address followed\n",
    "# with port number (if any). For example if you are running mongoDB on local machine then pass\n",
    "# the string \"mongodb://localhost\" else provide appropriate ipaddress with optional username/password credentials\n",
    "# the value \"localhost\" for host parameter otherwise provide actual ip/hostname with correct port no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q4. Using the database and the collection created in question number 3, write a code to insert one record, \n",
    "# and insert many records. Use the find() and find_one() methods to print the inserted record.\n",
    "# Answer :-\n",
    "from pymongo import MongoClient\n",
    "\n",
    "# Connect to the MongoDB server\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "\n",
    "# Access the database\n",
    "db = client['mydatabase']\n",
    "\n",
    "# Access the collection\n",
    "collection = db['mycollection']\n",
    "\n",
    "# Insert one record\n",
    "record_one = {\n",
    "    'name': 'John Doe',\n",
    "    'age': 30,\n",
    "    'email': 'johndoe@example.com'\n",
    "}\n",
    "collection.insert_one(record_one)\n",
    "\n",
    "# Insert many records\n",
    "records_many = [\n",
    "    {\n",
    "        'name': 'Jane Smith',\n",
    "        'age': 25,\n",
    "        'email': 'janesmith@example.com'\n",
    "    },\n",
    "    {\n",
    "        'name': 'Mike Johnson',\n",
    "        'age': 35,\n",
    "        'email': 'mikejohnson@example.com'\n",
    "    },\n",
    "    {\n",
    "        'name': 'Sarah Williams',\n",
    "        'age': 28,\n",
    "        'email': 'sarahwilliams@example.com'\n",
    "    }\n",
    "]\n",
    "collection.insert_many(records_many)\n",
    "\n",
    "# Print the inserted record using find_one()\n",
    "print('Inserted record:')\n",
    "print(collection.find_one())\n",
    "\n",
    "# Print all inserted records using find()\n",
    "print('All inserted records:')\n",
    "for record in collection.find():\n",
    "    print(record)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q5. Explain how you can use the find() method to query the MongoDB database. Write a simple code to \n",
    "# demonstrate this.\n",
    "# Answer :-\n",
    "# The find() method in MongoDB is used to query the database and retrieve documents that match the specified criteria. It allows you to filter documents based on various conditions such as field values, logical operators, regular expressions, and more.\n",
    "# Here's a simple example that demonstrates how to use the find() method in MongoDB using the pymongo library in Python:\n",
    "\n",
    "from pymongo import MongoClient\n",
    "\n",
    "# Connect to the MongoDB server\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "\n",
    "# Access the database\n",
    "db = client['mydatabase']\n",
    "\n",
    "# Access the collection\n",
    "collection = db['mycollection']\n",
    "\n",
    "# Query the database using find()\n",
    "query = {'age': {'$gte': 25}}  # Find documents where the 'age' field is greater than or equal to 25\n",
    "results = collection.find(query)\n",
    "\n",
    "# Print the matching documents\n",
    "for document in results:\n",
    "    print(document)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q6. Explain the sort() method. Give an example to demonstrate sorting in MongoDB.\n",
    "# Answer :-\n",
    "# The sort() method in MongoDB is used to sort the documents in a collection based on one or more fields. It allows you to specify the field(s) to sort on and the sort order (ascending or descending).\n",
    "# The sort() method takes a dictionary as an argument, where the keys represent the fields to sort on, and the values indicate the sort order. The sort order can be specified using 1 for ascending order and -1 for descending order.\n",
    "# Here's an example to demonstrate sorting in MongoDB using the pymongo library in Python:\n",
    "# Answer :-\n",
    "from pymongo import MongoClient\n",
    "\n",
    "# Connect to the MongoDB server\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "\n",
    "# Access the database\n",
    "db = client['mydatabase']\n",
    "\n",
    "# Access the collection\n",
    "collection = db['mycollection']\n",
    "\n",
    "# Query and sort the documents\n",
    "query = {}  # Empty query to retrieve all documents\n",
    "sort_criteria = [('age', 1), ('name', -1)]  # Sort by 'age' field in ascending order, then by 'name' field in descending order\n",
    "results = collection.find(query).sort(sort_criteria)\n",
    "\n",
    "# Print the sorted documents\n",
    "for document in results:\n",
    "    print(document)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q7. Explain why delete_one(), delete_many(), and drop() is used.\n",
    "# Answer :-The delete_one(), delete_many(), and drop() methods in MongoDB are used for deleting documents or collections from a database. Here's an explanation of each method:\n",
    "# 1.delete_one(filter): This method is used to delete a single document that matches the specified filter criteria. It takes a filter as an argument, which defines the criteria for selecting the document to delete. If multiple documents match the filter, it will delete only the first matching document.\n",
    "# 2.delete_many(filter): This method is used to delete multiple documents that match the specified filter criteria. It takes a filter as an argument, similar to delete_one(). It will delete all the documents that match the filter.\n",
    "# Both delete_one() and delete_many() methods provide a way to selectively remove documents from a collection based on specific criteria. They are useful for removing unwanted or outdated data from the database.\n",
    "# Here's an example to demonstrate the usage of delete_one() and delete_many() in MongoDB using the pymongo library in Python:\n",
    "\n",
    "from pymongo import MongoClient\n",
    "\n",
    "# Connect to the MongoDB server\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "\n",
    "# Access the database\n",
    "db = client['mydatabase']\n",
    "\n",
    "# Access the collection\n",
    "collection = db['mycollection']\n",
    "\n",
    "# Delete one document\n",
    "filter_one = {'name': 'John Doe'}\n",
    "result_one = collection.delete_one(filter_one)\n",
    "print('Deleted count (delete_one):', result_one.deleted_count)\n",
    "\n",
    "# Delete multiple documents\n",
    "filter_many = {'age': {'$lt': 30}}  # Delete documents where 'age' is less than 30\n",
    "result_many = collection.delete_many(filter_many)\n",
    "print('Deleted count (delete_many):', result_many.deleted_count)\n",
    "\n",
    "# In this example, we connect to the MongoDB server, access the database, and collection. We define a filter using a dictionary to specify the criteria for deleting documents. In the first case, we use delete_one() to delete a document where the 'name' field is 'John Doe'. In the second case, we use delete_many() to delete documents where the 'age' field is less than 30.\n",
    "# Both methods return a DeleteResult object that contains information about the delete operation. The deleted_count property of the DeleteResult object indicates the number of documents that were deleted.\n",
    "\n",
    "# 1.drop(): This method is used to completely remove a collection from a database. It deletes all the documents within the collection and removes the collection itself. The drop() method does not take any arguments.\n",
    "# Here's an example to demonstrate the usage of drop() in MongoDB using the pymongo library in Python:\n",
    "\n",
    "from pymongo import MongoClient\n",
    "# Connect to the MongoDB server\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "\n",
    "# Access the database\n",
    "db = client['mydatabase']\n",
    "\n",
    "# Drop the collection\n",
    "collection = db['mycollection']\n",
    "collection.drop()\n",
    "\n",
    "# In this example, we connect to the MongoDB server, access the database, and collection. We use the drop() method on the collection object to remove the entire collection.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}