Feb_17_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 1\n",
    "\n",
    "MongoDB is a NoSQL, document-based database that stores data in JSON-like documents, making it a popular choice for web and mobile applications that require flexible, scalable, and high-performance data storage. It is an open-source, cross-platform database that offers high availability, automatic scaling, and horizontal scaling features.\n",
    "\n",
    "Non-relational databases, also known as NoSQL databases, are databases that do not use a traditional relational database model, which means they do not use tables with rows and columns. Instead, they store data in a flexible and schema-less format such as documents, graphs, or key-value pairs. Non-relational databases are often preferred for their flexibility, scalability, and performance.\n",
    "\n",
    "MongoDB is preferred over SQL databases in scenarios where the data is unstructured or semi-structured, such as for web applications that require the storage of large volumes of unstructured data, such as social media posts, sensor data, or multimedia files. MongoDB is also a good choice when you need to store large amounts of data that may change frequently, as it allows for schema flexibility and dynamic updates.\n",
    "\n",
    "In summary, MongoDB is a popular NoSQL database that offers high performance, scalability, and flexibility, making it a good choice for web and mobile applications that require dynamic and unstructured data storage. Non-relational databases, in general, are preferred over SQL databases in scenarios where data is unstructured or semi-structured and where scalability and flexibility are important."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 2\n",
    "\n",
    "MongoDB is a powerful, flexible, and scalable NoSQL database that offers many features, including:\n",
    "\n",
    "1) Document-oriented storage: MongoDB stores data in flexible, JSON-like documents, which can have dynamic schemas and can be nested.\n",
    "\n",
    "2) High availability: MongoDB supports replica sets, which are groups of MongoDB servers that maintain multiple copies of data for high availability and automatic failover.\n",
    "\n",
    "3) Automatic sharding: MongoDB can automatically partition data across multiple servers, making it easy to scale horizontally.\n",
    "\n",
    "4) Indexing: MongoDB supports many types of indexes, including compound indexes, geospatial indexes, and text indexes, which help to optimize query performance.\n",
    "\n",
    "5) Aggregation framework: MongoDB's aggregation framework is a powerful tool for performing advanced data analysis, grouping, and aggregation on data.\n",
    "\n",
    "6) MapReduce: MongoDB supports MapReduce, a powerful data processing technique that allows for efficient processing of large datasets.\n",
    "\n",
    "7) Security: MongoDB provides several security features, including authentication, access control, encryption at rest, and auditing, to protect your data and ensure compliance with security standards.\n",
    "\n",
    "8) Schema flexibility: MongoDB's document-oriented data model allows for schema flexibility, making it easy to handle unstructured and semi-structured data.\n",
    "\n",
    "9) Dynamic updates: MongoDB allows for dynamic updates, so you can easily modify data in real-time without worrying about schema changes.\n",
    "\n",
    "In summary, MongoDB is a feature-rich NoSQL database that offers document-oriented storage, high availability, automatic sharding, indexing, aggregation, and MapReduce capabilities. It is also highly secure, flexible, and supports dynamic updates, making it a powerful choice for many different use cases."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 3\n",
    "\n",
    "here's an example code to connect to MongoDB from Python using the pymongo library, and create a database and a collection in MongoDB:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pymongo\n",
    "\n",
    "# Establish a connection to the MongoDB server\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "\n",
    "# Create a new database called \"mydatabase\"\n",
    "db = client[\"mydatabase\"]\n",
    "\n",
    "# Create a new collection called \"customers\" in the \"mydatabase\" database\n",
    "collection = db[\"customers\"]\n",
    "\n",
    "# Insert a document into the \"customers\" collection\n",
    "customer = {\"name\": \"John Doe\", \"email\": \"johndoe@example.com\"}\n",
    "result = collection.insert_one(customer)\n",
    "print(\"Inserted document with ID: {}\".format(result.inserted_id))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "This code uses the pymongo library to connect to a MongoDB server running on the local machine at the default port 27017. It then creates a new database called \"mydatabase\" and a new collection called \"customers\" within that database. Finally, it inserts a new document (a customer) into the \"customers\" collection and prints the ID of the newly inserted document.\n",
    "\n",
    "Note that you will need to have the pymongo library installed to run this code. You can install it using pip by running the following command in your terminal or command prompt:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "pip install pymongo"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 4\n",
    "\n",
    "Here's an example code to insert one record and multiple records into the \"customers\" collection we created earlier, and then use the find() and find_one() methods to print the inserted record(s):"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pymongo\n",
    "\n",
    "# Establish a connection to the MongoDB server\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "\n",
    "# Get the \"mydatabase\" database and \"customers\" collection\n",
    "db = client[\"mydatabase\"]\n",
    "collection = db[\"customers\"]\n",
    "\n",
    "# Insert one record into the \"customers\" collection\n",
    "customer1 = {\"name\": \"Jane Doe\", \"email\": \"janedoe@example.com\"}\n",
    "result1 = collection.insert_one(customer1)\n",
    "print(\"Inserted document with ID: {}\".format(result1.inserted_id))\n",
    "\n",
    "# Insert many records into the \"customers\" collection\n",
    "customers2 = [\n",
    "  {\"name\": \"Bob Smith\", \"email\": \"bobsmith@example.com\"},\n",
    "  {\"name\": \"Alice Johnson\", \"email\": \"alicejohnson@example.com\"},\n",
    "  {\"name\": \"Charlie Brown\", \"email\": \"charliebrown@example.com\"}\n",
    "]\n",
    "result2 = collection.insert_many(customers2)\n",
    "print(\"Inserted {} documents with IDs: {}\".format(len(result2.inserted_ids), result2.inserted_ids))\n",
    "\n",
    "# Find and print the first record in the \"customers\" collection\n",
    "customer = collection.find_one()\n",
    "print(customer)\n",
    "\n",
    "# Find and print all records in the \"customers\" collection\n",
    "customers = collection.find()\n",
    "for customer in customers:\n",
    "    print(customer)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "This code inserts one record (Jane Doe) using insert_one(), and multiple records (Bob Smith, Alice Johnson, and Charlie Brown) using insert_many() into the \"customers\" collection. It then uses find_one() to retrieve and print the first record in the collection, and find() to retrieve and print all records in the collection.\n",
    "\n",
    "Note that the find() method returns a cursor object that you can loop through to print all documents in the collection."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 5\n",
    "\n",
    "The find() method is used to query a MongoDB collection for documents that match a specified query criteria. You can use the find() method to retrieve all documents in a collection, or to retrieve a subset of documents based on specific query criteria.\n",
    "\n",
    "Here is an example code to demonstrate how to use the find() method to query a MongoDB database:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pymongo\n",
    "\n",
    "# Establish a connection to the MongoDB server\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "\n",
    "# Get the \"mydatabase\" database and \"customers\" collection\n",
    "db = client[\"mydatabase\"]\n",
    "collection = db[\"customers\"]\n",
    "\n",
    "# Query the \"customers\" collection for all documents\n",
    "all_customers = collection.find()\n",
    "for customer in all_customers:\n",
    "    print(customer)\n",
    "\n",
    "# Query the \"customers\" collection for documents where the \"name\" field is \"John Doe\"\n",
    "query = {\"name\": \"John Doe\"}\n",
    "john_doe_customers = collection.find(query)\n",
    "for customer in john_doe_customers:\n",
    "    print(customer)\n",
    "\n",
    "# Query the \"customers\" collection for documents where the \"age\" field is greater than 25\n",
    "query = {\"age\": {\"$gt\": 25}}\n",
    "age_gt_25_customers = collection.find(query)\n",
    "for customer in age_gt_25_customers:\n",
    "    print(customer)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this example code, we first connect to the MongoDB server and retrieve the \"mydatabase\" database and \"customers\" collection. We then use the find() method to query the \"customers\" collection for all documents, and print each document in the collection.\n",
    "\n",
    "Next, we use the find() method with a query criteria to retrieve documents where the \"name\" field is \"John Doe\", and then print each document in the resulting cursor object. We then use the find() method with another query criteria to retrieve documents where the \"age\" field is greater than 25, and print each document in the resulting cursor object.\n",
    "\n",
    "Note that in the last example, we used a query operator ($gt) to specify the comparison operator for the \"age\" field in the query. MongoDB supports a wide range of query operators that you can use in your queries to match documents based on specific criteria."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 6\n",
    "\n",
    "The sort() method is used to sort the results of a query in MongoDB. You can specify one or more fields by which to sort the results, and you can sort the results in ascending or descending order.\n",
    "\n",
    "The sort() method takes an optional parameter that specifies the sort order. If the parameter is 1, the results are sorted in ascending order; if the parameter is -1, the results are sorted in descending order.\n",
    "\n",
    "Here's an example to demonstrate sorting in MongoDB using the sort() method:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pymongo\n",
    "\n",
    "# Establish a connection to the MongoDB server\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "\n",
    "# Get the \"mydatabase\" database and \"customers\" collection\n",
    "db = client[\"mydatabase\"]\n",
    "collection = db[\"customers\"]\n",
    "\n",
    "# Query the \"customers\" collection and sort the results by the \"name\" field in ascending order\n",
    "sorted_customers = collection.find().sort(\"name\", 1)\n",
    "\n",
    "# Print the sorted results\n",
    "for customer in sorted_customers:\n",
    "    print(customer)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this example, we first connect to the MongoDB server and retrieve the \"mydatabase\" database and \"customers\" collection. We then use the find() method to query the \"customers\" collection for all documents, and sort the results by the \"name\" field in ascending order using the sort() method.\n",
    "\n",
    "We then print each document in the resulting cursor object, which contains the sorted results of the query. By default, the sort() method sorts the results in ascending order if no sort order is specified, so we explicitly specified the 1 parameter to indicate that we want to sort in ascending order by the \"name\" field.\n",
    "\n",
    "You can also sort by multiple fields by passing a list of fields and sort orders to the sort() method. For example, you could sort by the \"name\" field in ascending order, and then by the \"age\" field in descending order, by passing the following list to the sort() method: [(\"name\", 1), (\"age\", -1)]."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Answer 7\n",
    "\n",
    "delete_one(), delete_many(), and drop() are methods used in MongoDB to delete documents or collections from the database.\n",
    "\n",
    "delete_one() is used to delete a single document from a collection that matches a specified filter. The method takes a filter parameter that specifies the document to be deleted, and it deletes the first document that matches the filter. If no document matches the filter, the method does nothing.\n",
    "\n",
    "delete_many() is used to delete multiple documents from a collection that match a specified filter. The method takes a filter parameter that specifies the documents to be deleted, and it deletes all documents that match the filter. If no documents match the filter, the method does nothing.\n",
    "\n",
    "drop() is used to delete an entire collection from the database. The method does not take any parameters, and it deletes the entire collection and all of its documents.\n",
    "\n",
    "These methods are useful in scenarios where you need to remove data from the database. For example, if you have a collection of user data, you may want to use delete_one() to remove a single user's data when they delete their account, or delete_many() to remove multiple users' data at once. If you decide to remove a collection entirely, you can use the drop() method.\n",
    "\n",
    "It's important to be careful when using these methods, as they can permanently delete data from the database. Always make sure you have a backup of your data before performing any delete operations, and double-check that you're deleting the correct documents or collections before executing the delete methods."
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}