DS108-Databases/NoSQL/DS108NoSQL-L1-Getting-Started-With-NoSQL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS108 Databases NoSQL: Lesson One - Getting Started With NoSQL"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS108L6_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS108L6_toc)\n",
    "    * [Page 1 - Getting Started With NoSQL](#DS108L6_page_1)\n",
    "    * [Page 2 - Setup](#DS108L6_page_2)\n",
    "    * [Page 3 - What is NoSQL?](#DS108L6_page_3)\n",
    "    * [Page 4 - Creating a Database](#DS108L6_page_4)\n",
    "    * [Page 5 - Connecting to MongoDB with VS Code](#DS108L6_page_5)\n",
    "    * [Page 6 - MongoDB - Playgrounds](#DS108L6_page_6)\n",
    "    * [Page 7 - MongoDB Collections](#DS108L6_page_7)\n",
    "    * [Page 8 - Data Types](#DS108L6_page_8)\n",
    "    * [Page 9 - Relationships](#DS108L6_page_9)\n",
    "    * [Page 10 - Inserting Documents](#DS108L6_page_10)\n",
    "    * [Page 11 - Key Terms](#DS108L6_page_11)\n",
    "    * [Page 12 - Lesson 1 Practice Hands-On](#DS108L6_page_12)\n",
    "    * [Page 13 - Lesson 1 Practice Hands-On solution](#DS108L6_page_13)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Getting Started With NoSQL<a class=\"anchor\" id=\"DS108L6_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9e0b3174-5ca1-45ec-8509-ca204b09e786",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/245797034\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7f80604eb610>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Getting Started With NoSQL\n",
    "VimeoVideo('245797034', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "# Overview\n",
    "\n",
    "Welcome to the world of Database Solutions outside of the scope of the traditional relational database model, known collectively as `NoSQL`. During this course, you will learn the basics of a particular kind of NoSQL solution known as MongoDB, which has been labeled as \"web-scale\" in some circles. Databases have always served as a core component of software development. Understanding how to store and retrieve data is essential to any non-trivial application. Throughout this course, you will learn more about the history of databases, the different types of databases, and more. Understanding document databases and NoSQL solutions provide a valuable skill that will be useful in nearly any development environment.\n",
    "\n",
    "By the end of this course, you will be able to design, implement and modify basic databases, as well as interact to retrieve, store, and modify meaningful data.\n",
    "\n",
    "Databases are a complex topic with a lot of history, but this foundational course will prepare you with a basic working knowledge of these concepts.\n",
    "\n",
    "---\n",
    "\n",
    "## Different Types of NoSQL Databases\n",
    "\n",
    "In this course, you will be using the most common form of NoSQL database, a document store database. However, there are other forms of NoSQL databases. There are Key-Value databases, Graph-based databases, Wide-Column stores, and the Document store you'll be using here.\n",
    "\n",
    "### Document Stores\n",
    "\n",
    "Document store databases are likely the most common NoSQL databases you will encounter. They contain documents usually in a JSON format but include a unique key maintained by the data store to identify each document. Using the unique key, one document can reference another document similar to a foreign key in a SQL table. Since there is no static structure of the JSON documents, the data store can remain very flexible. The most common Document Store databases are MongoDB and Couchbase. MongoDB is the database you will be using in this course.\n",
    "\n",
    "---\n",
    "\n",
    "### Key-Value Stores\n",
    "\n",
    "A Key-Value store is the simplest and fastest NoSQL database since it only contains an identifier and value for each record, which is similar to the use of variables in programming languages. An identifier is used to determine where a piece of information can be located within the database. This is the key. To return the value, simply use the key which represents the storage of that value. Some of the more common Key-Value store databases are Redis, Riak, and Amazon DynamoDB.\n",
    "\n",
    "---\n",
    "\n",
    "### Graph Databases\n",
    "\n",
    "Graph databases are very similar to document stores with an additional layer of relationship binding between the documents. Instead, these documents are called `Verticies`, `Nodes` or `Points` while the relationships between these vertices are called `Edges`. Graph databases are designed so that vertices are based around nouns such as persons, places, and objects. Using edges to declare the relationships between vertices rather than a key/foreign-key relationship separates the connections from the data itself. This allows for a change of relationships or data to not affect each other. Some of the more popular Graph Databases are Neo4J.\n",
    "\n",
    "---\n",
    "\n",
    "### Wide Column Stores\n",
    "\n",
    "Wide column stores are perhaps the hardest to understand. The simplest way to think of them is like a SQL database table, but each record has its own column name and, the key is required. Another way of imagining it is like a Document store where a predefined key is associated with the document, and the document cannot have any sub-documents. The complexity of Wide Column stores tends to shy people away from using them, but large amounts of data can be stored this way conveniently without the need for a specific structured table like a SQL database has. They also tend to be incredibly fast because of the one-for-one relationship between the key and the data. The most popular Wide Column store database is Cassandra."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Setup<a class=\"anchor\" id=\"DS108L6_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "88339d30-5bb8-47b1-adc9-94c359a0bfb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/566314868\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1045c87c0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Mongo Atlas Cluster Setup\n",
    "VimeoVideo('566314868', width=720, height=480)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3235f7f6-6bb0-4ffd-8ac2-b8bab4634e6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/566317301\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1045c81c0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Step 2 Mongo Shell Mac\n",
    "VimeoVideo('566317301', width=720, height=480)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "15059755-2d61-482b-8329-c317fc2cf2d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/566317732\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1045c8850>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Mongo Shell Windows\n",
    "VimeoVideo('566317732', width=720, height=480)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9cdd6e6d-2c6d-422e-8b2c-6375c0e0d3e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/567639870\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x1045c8a30>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Mongo Shell in VSC\n",
    "VimeoVideo('567639870', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# Setup\n",
    "\n",
    "To continue with this lesson, you will need to set up and configure the required software on your computer. The instructions are below.\n",
    "\n",
    "---\n",
    "\n",
    "## Required Software\n",
    "\n",
    "- **[Visual Studio Code](https://code.visualstudio.com/)**\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "## Setup Instructions\n",
    "\n",
    "\n",
    "For this course, you will be using MongoDB, a popular NoSQL implementation. Your MongoDB database will be provided by **Atlas**, a cloud-hosted database service specializing in MongoDB.\n",
    "\n",
    "Before you start, you will first need to sign up for a free MongoDB Atlas account at **[www.mongodb.com](https://www.mongodb.com/)**.\n",
    "\n",
    "![Mongo DB website. The main page of the Mongo DB website. It says Mongo DB atlas. Deploy a fully managed cloud database in minutes. There is an arrow in the upper right corner pointing to a button that says Try Free.](Media/MongoDB-Website-Splash.png) _Figure 1-1: MongoDB Website_\n",
    "\n",
    "Click on the `Try Free` button on the MongoDB.com website, located in the top right corner of the page. This will take you to a signup screen that looks like the one below:\n",
    "\n",
    "![Mongo DB signup. Signup page for Mongo DB. There are text boxes to fill in with a username, first and last name, and password. An arrow points to the button at the bottom of the page that reads \"Get started free\".](Media/MongoDB-Signup.png) _Figure 1-2: MongoDB Signup_\n",
    "\n",
    "Once you have signed up, you will be directed to the MongoDB Atlas website to create your first database cluster.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>A <strong>database cluster</strong> refers to several database servers hosting a database instance.  This creates redundancy since more than one server can be connected to for the same data.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "Click on the button that says `Build my first cluster` to begin creating your first database.\n",
    "\n",
    "![Build First Cluster. Splash page for Mongo DB Atlas. It says Welcome. Mongo DB Atlas is the best way to run Mongo DB. You won't have to worry about installing, configuring, or managing your database anymore. Get started by building your first cluster. An arrow is pointing to a button that reads Build my first cluster.](Media/MongoDB-BuildCluster.png) _Figure 1-3: Build First Cluster_\n",
    "\n",
    "Make sure to click `(FREE) Shared` cluster.\n",
    "\n",
    "![Cluster (FREE) Shared.](Media/1-2-1.png) _Figure NEW: Free Shared Cluster_\n",
    "\n",
    "Next, you'll be prompted to select a region and provider to host your MongoDB instance. The default selections will have a green box around them. Make sure the selection for your region is a `FREE TIER AVAILABLE` selection. It's recommended to use `AWS` and `N. Virginia`. Then click on the `Create Cluster` button at the bottom of the page.\n",
    "\n",
    "![Cluster select. Icons are shown for several different cloud providers and regions. Arrows point to A W S and N. Virginia in North America. Another arrow is pointing to the create cluster button at the bottom of the screen.](Media/MongoDB-ClusterSelection.png) _Figure 1-4: Cluster Selection_\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may be prompted to complete a Captcha validation process before you can continue creating the cluster.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "Now you have your first cluster created. Great job! In a later lesson, you will set up your first database using MongoDB Atlas."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - What is NoSQL?<a class=\"anchor\" id=\"DS108L6_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# What is NoSQL?\n",
    "\n",
    "The term **NoSQL** refers to a data storage system that does not have the relational constraints and model that a traditional SQL RDBMS (relational database management system) has. NoSQL stands for \"Not SQL,\" \"Non-SQL,\" or more recently, \"Not Only SQL.\" It is a category of storage solutions, of which there are various types. The last term, \"Not Only SQL,\" actually refers to a storage system that is not SQL, but it is similar to SQL when interacting with your data. The main difference between SQL and NoSQL is the presence of a predefined schema. With a SQL database, you create tables that contain only certain information and act as a blueprint for organizing your data. With NoSQL, the NoSQL databases are built to allow data insertion without a predefined schema or blueprint in SQL.\n",
    "\n",
    "There are _four_ categories of storage solutions for most of the systems that qualify as NoSQL. As new ones are continually coming into existence, there is some cross-pollination of ideas and functionality, so these categories are by no means absolute. However, at this time, most of the solutions can fit into these four types: **Document Database**, **Key-Value Database**, **Graph Database**, and **Object Database**.\n",
    "\n",
    "1.  **Document Database**: This is the primary version of NoSQL that you will be interested in, as MongoDB is a document-oriented database. The key concept for a document database is that data for a particular purpose or entity are grouped as a single document and stored as such. Each document in your database will have a unique identifier, which you will use to complete your CRUD operations. The most popular type of structures for documents in these databases are BSON, XML, or JSON.\n",
    "\n",
    "2.  **Key-Value Database**: Probably the most aptly named version of a NoSQL solution, a Key-Value database is simply that - a single, unique key for every set of data that you store in the database. It is sometimes referred to as a dictionary - as it works in the same fashion. In a dictionary, the word itself that you look up would be the _key_, and the _value_ associated with that key would be the word's definition.\n",
    "\n",
    "3.  **Graph Database**: This is a term you should be familiar with, as with the explosion of social networking, they have gained popularity quite a bit. Under the hood of a Graph Database, you will usually find the storage to be a Key-Value or Document Database. Still, they are structured with nodes and edges properties to represent relationships instead of containing the relationships in the data like an RDBMS does.\n",
    "\n",
    "4.  **Object Database**: An Object-Oriented database, sometimes abbreviated OODBMS, is a database where the data itself is stored in the form of objects. An object will contain all information about a specific record in the database. Think of it like a car - it has weight, color, wheels, windows, and it stops and starts. All of this information is contained in one place: an object. An object also allows for different types of data.\n",
    "\n",
    "Now that you have an idea of what NoSQL is, it is time to dive into creating a database.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Creating a Database<a class=\"anchor\" id=\"DS108L6_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Creating a Database\n",
    "\n",
    "Previously in this lesson, you signed up for `MongoDB Atlas`, which is where you will be storing all of your data in your database. Next, we need to make sure you can access your database.\n",
    "\n",
    "1. Click on `Database Access`:\n",
    "\n",
    "   ![Database access configuration. Window showing the cluster menu. The database access option is selected. On the right side of the screen, it shows part of a sandbox with the cluster tier, region, type, and stitched app.](Media/1-4-1.png) _Figure 1-6: Database Access Configuration_\n",
    "\n",
    "2. Click on `add new database user`:\n",
    "\n",
    "   ![Add new database user. Screen in the application that says create a new database user. Set up database users, permissions, and authentication credentials to connect to your clusters. There is a large button that says Add new Database user that highlighted.](Media/MongoInstall3.png) _Figure 1-7: Add New Database User_\n",
    "\n",
    "   The `Add New User` screen is where you can add user accounts and set their permissions for accessing your databases. Enter the name of `dbuser` and set the password to `Password1!`. Then click on the `Add User` button on the bottom right of the screen.\n",
    "\n",
    "   ![Add DB User. A screen that shows SCRAM authentication with two textboxes to enter username and password. User privileges icons and menus are across the bottom of the screen. They include Atlas Admin, Read and Write to any database, which is highlighted, Only read any database and select custom role. An arrow is pointing to the add user button at the bottom right of the screen.](Media/MongoDB-AddDbUser.png) _Figure 1-8: Add dbuser_\n",
    "\n",
    "   You should now see the new `dbuser` account listed under the Security section of your cluster.\n",
    "\n",
    "3. Next on your list is to `Whitelist your IP address`. Click on `Network Access`:\n",
    "\n",
    "   <div class=\"panel panel-success\">\n",
    "   <div class=\"panel-heading\">\n",
    "       <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "   </div>\n",
    "   <div class=\"panel-body\">\n",
    "       <p>Whitelist means to allow access from that location.  Blacklist means to disallow access from that location.\n",
    "       </p>\n",
    "   </div>\n",
    "   </div>\n",
    "\n",
    "   ![Network Access.  Folder directory with the network access option highlighted. The username DB user and the authentication method SCRAM are shown.](Media/MongoInstall4.png) _Figure 1-9: Network Access_\n",
    "\n",
    "4. Then click on `Add IP Address`:\n",
    "\n",
    "   ![Add an IP Address. Screen that reads Whitelist an IP Address. Configure which IP Addresses can access your cluster. There is a large button that says Add IP Address that is highlighted.](media/MongoInstall5.png) _Figure 1-10: Add IP Address_\n",
    "\n",
    "5. From the `Add Whitelist Entry` screen, you will see _two_ buttons. One button will state `ADD CURRENT IP ADDRESS` and the other will state `ALLOW ACCESS FROM ANYWHERE`. Click on the `ALLOW ACCESS FROM ANYWHERE` button. This will add all the IP addresses to the whitelist and prevent any issues connecting to your database in the future. This will set the `Whitelist Entry` field to a value of `0.0.0.0/0`. Then click on the `Confirm` button.\n",
    "\n",
    "   ![Add access from anywhere. An arrow points to a button that says add access from anywhere on a screen titled Add Whitelist Entry. Another arrow points to a button in the bottom right corner that says confirm.](Media/MongoDB-AddWhitelistEntry.png) _Figure 1-11: Add Access From Anywhere_\n",
    "\n",
    "The final step in the `Get Started` checklist is to connect to your database. To do that, you will need to install the MongoDB extension for VS Code. You'll cover that in the next topic.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Connecting to MongoDB with VS Code<a class=\"anchor\" id=\"DS108L6_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "# Connecting to MongoDB with VS Code\n",
    "\n",
    "Before you connect to your MongoDB database, you will need to install the official MongoDB for VS Code extension and a connection string from the MongoDB website. To connect and install the MongoDB for VS Code, follow the steps below:\n",
    "\n",
    "## Connection String\n",
    "\n",
    "1. Make sure you are on the tab labeled `Databases` on the left. You can then click the `Connect` button under your Database Deployments information.\n",
    "\n",
    "![Connect button.](Media/mongoConnect-1.png) _Figure NEW: Connect Button_\n",
    "\n",
    "2. After you click on the `Connect` button, you will be presented with _three_ options of how to connect to your MongoDB database cluster. The third option is `Connect using MongoDB Compass`, which is the option you want to click.\n",
    "\n",
    "![Connect Options.](Media/mongoConnect-2.png) _Figure NEW: Connect Options_\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p><strong><em>Connect with MongoDB Shell</em></strong> will walk you through connecting via the Mongo Shell.  Some developers prefer this interface.</p>\n",
    "        <p><strong><em>Connect Your Application</em></strong> will walk you through connecting a Java, Python, Ruby, or NodeJS application to the database cluster.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "3. The next screen will show your connection string. You do not need to install MongoDB Compass as we will be using the VS Code extension. Copy this connection string and save it somewhere as you will need it in the next section.\n",
    "\n",
    "![Connection String.](Media/mongoConnect-3.png) _Figure NEW: Connection String_\n",
    "\n",
    "## Installing MongoDB for VS Code\n",
    "\n",
    "1. Open the Extensions view and search for `MongoDB` to filter the results. Select the MongoDB for VS Code extension.\n",
    "\n",
    "![MongoDB for VS Code](Media/mongoVSC-1.png) _Figure NEW: MongoDB for VS Code_\n",
    "\n",
    "2. Once you've installed the MongoDB for VS Code extension, you'll notice there is a new MongoDB Activity Bar view. Select the MongoDB view, and you'll see the MongoDB Explorer.\n",
    "\n",
    "![MongoDB for VS Code](Media/mongoVSC-2.png) _Figure NEW: MongoDB for VS Code_\n",
    "\n",
    "3. To connect to a MongoDB database, select Add Connection and then click the `connect with a connection string` link. An input area will pop up - paste the connection string we copied in the Connection String section (you may need to right-click and choose Paste).\n",
    "\n",
    "![MongoDB for VS Code](Media/mongoVSC-3.png) _Figure NEW: MongoDB for VS Code_\n",
    "\n",
    "4. After pasting your connection string, you will need to change the section that says `<password>` to the password you assigned to `dbuser`, which should be `Password1!` - Once changed, press Enter to connect.\n",
    "\n",
    "![MongoDB for VS Code](Media/mongoVSC-4.png) _Figure NEW: MongoDB for VS Code_\n",
    "\n",
    "5. VS Code should now be connected to MongoDB!\n",
    "\n",
    "![MongoDB for VS Code](Media/mongoVSC-5.png) _Figure NEW: MongoDB for VS Code_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - MongoDB - Playgrounds<a class=\"anchor\" id=\"DS108L6_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "# MongoDB - Playgrounds\n",
    "\n",
    "---\n",
    "\n",
    "## MongoDB Playgrounds\n",
    "\n",
    "**MongoDB Playgrounds** is included with the VS Code extension. Playgrounds allow you to quickly test out MongoDB commands. It is a great way to learn how to use MongoDB. It is also a great way to learn how to use VS Code.\n",
    "\n",
    "MongoDB Playgrounds provide intelligent autocomplete and commands with helpful syntax highlighting.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p> MongoDB for VS Code splits your Playground window to display your Playground Result in the right-side pane. </p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "## Your first MongoDB Playground\n",
    "\n",
    "1. In the Playgrounds panel of MongoDB for VS Code, click Create New Playground.\n",
    "\n",
    "![MongoDB Playgrounds](Media/playgrounds-1.png) _Figure NEW: MongoDB Playgrounds_\n",
    "\n",
    "2. Due to us already setting up a active connection your playground should already be connected. If you do **NOT** have an active connection, you will see `Click here to add connection` at the top of your playground. Click on the `Add Connection` button and enter the connection string we copied in the Connection String section.\n",
    "\n",
    "![MongoDB Playgrounds](Media/playgrounds-2.png) _Figure NEW: MongoDB Playgrounds_\n",
    "\n",
    "3. The playground will show a template with example commands. You will not be using the commands in this template, but feel free to take a look and see how they work. You can delete everything in the template to start from scratch. You are now ready to write your own commands in the following section.\n",
    "\n",
    "![MongoDB Playgrounds](Media/playgrounds-3.png) _Figure NEW: MongoDB Playgrounds_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - MongoDB Collections<a class=\"anchor\" id=\"DS108L6_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "# MongoDB Collections\n",
    "\n",
    "**MongoDB Collections** are a grouping of MongoDB documents and are the equivalent of an RDBMS table. A collection exists within a single database and does not enforce a schema (or a blueprint of your data). Documents within a collection can have different fields. Typically, all documents in a collection have a similar or related purpose. You can refer to this as a _flexible schema_.\n",
    "\n",
    "Within collections are **documents**, which are independent units that make performance better (related data is read contiguously off the disk) and make it easier to distribute data across multiple servers while preserving its locality. Each document has a **document ID**, which is the unique identifier for a document. When working with Collections and Documents, you will perform CRUD (Create, Read, Update, Delete) operations again.\n",
    "\n",
    "---\n",
    "\n",
    "## Creating Your First Collection\n",
    "\n",
    "You will start with a very important acronym in the data storage universe - **CRUD**. CRUD is an acronym for Create, Retrieve, Update and Delete. This refers to the category of operations in an RDBMS known as DML (data manipulation language). Also, in MongoDB, you can use a set of operations to do the same types of things with the documents you will create and retrieve.\n",
    "\n",
    "But before you can get into the CRUD operations within MongoDB, you will first need to build the construct (the collection) inside the database in which you store your data. For this example, you will use your connection to the database through the Mongo Playground to create your first collection.\n",
    "\n",
    "A function is a predefined set of code that can call to executed by the user. In this case, you want to execute a function called `createCollection`. To call this function, you use a set of open and closed parenthesis `()`. But there's one additional thing you need to know before you can execute the function. In order for this function to work, it needs to know the name of the collection to create. You pass this to the function through something called an argument, and the argument is inserted between the parenthesis. If you have done any programming before, this will look very familiar. If you haven't, copy the text below into your terminal and press enter to execute the function:\n",
    "\n",
    "```text\n",
    "db.createCollection(\"appusers\");\n",
    "```\n",
    "\n",
    "The above command executes the `createCollection` function on the database (DB is short for database). You are passing the argument of `appusers` as the name you want to give this collection.\n",
    "\n",
    "To execute the function, you need to highlight the function and click the `Run Selected Lines From Playground` message or press the play button on the top right.\n",
    "\n",
    "![MongoDB Playgrounds](Media/playgrounds-4.png) _Figure NEW: MongoDB Playgrounds_\n",
    "\n",
    "After executing this function, you will get a response back from the server with some information about the result of your request.\n",
    "\n",
    "![MongoDB Playgrounds](Media/playgrounds-5.png) _Figure NEW: MongoDB Playgrounds_\n",
    "\n",
    "The only significant thing to note at this time is that the `\"ok\"` value is set to 1, indicating that the request was processed successfully and your new collection called `appusers` is created.\n",
    "\n",
    "Now you can verify that this collection has been created on the Atlas website.\n",
    "\n",
    "Open your browser, navigate to **[https://cloud.mongodb.com](https://cloud.mongodb.com)**, and log back in if you aren't logged in already.\n",
    "\n",
    "From your `Overview` tab in Atlas, click on the `Cluster0` active hyperlink.\n",
    "\n",
    "![Cluster Hyperlink. The clusters sandbox. An arrow is pointing to cluster 0.](Media/atlas-1.png) _Figure 1-37: Cluster Hyperlink_\n",
    "\n",
    "In your `Cluster0` screen, you will find a `Collections` tab, click on `Collections`.\n",
    "\n",
    "![Collections tab. An arrow is pointing to the Collections tab in the clusters sandbox 0 windows.](media/MongoDB-CollectionsTab.png) _Figure 1-38: Collections Tab_\n",
    "\n",
    "You should see the `appusers` collection listed in the collections of your database.\n",
    "\n",
    "![Collections list. The collection test app users are highlighted inside the collections tab.](Media/MongoDB-CollectionsList.png) _Figure 1-39: Collections List_\n",
    "\n",
    "Great work! Now you have a place to store your documents in your database. Continue, and you'll explore how to add data to these documents.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Data Types<a class=\"anchor\" id=\"DS108L6_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "# Data Types\n",
    "\n",
    "Before you dive into inserting documents into your collection, you need to know what types of data are allowed in a NoSQL database. When creating a document, the data within it needs to live somewhere. When working with MongoDB, the data lives within a JSON (pronounced jay-son) file.\n",
    "\n",
    "---\n",
    "\n",
    "## JSON\n",
    "\n",
    "Below is the definition of JSON from the MongoDB website:\n",
    "\n",
    "> _JavaScript Object Notation (JSON) is a lightweight data-interchange format that is easy for humans to read and write and for machines to parse and generate. Along with XML, JSON is the main format for data interchange used on the modern web. JSON supports all basic data types: numbers, strings, booleans, in addition to arrays and hashes._\n",
    "\n",
    "MongoDB and other document databases use JSON documents to store records, while relational databases use tables and rows to store records. Below you will find an example of a JSON document:\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"_id\": 1,\n",
    "  \"name\": { \"first\": \"John\", \"last\": \"Backus\" },\n",
    "  \"contribs\": [\"Fortran\", \"ALGOL\", \"Backus-Naur Form\", \"FP\"],\n",
    "  \"awards\": [\n",
    "    {\n",
    "      \"award\": \"W.W. McDowell Award\",\n",
    "      \"year\": 1967,\n",
    "      \"by\": \"IEEE Computer Society\"\n",
    "    },\n",
    "    {\n",
    "      \"award\": \"Draper Prize\",\n",
    "      \"year\": 1993,\n",
    "      \"by\": \"National Academy of Engineering\"\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "```\n",
    "\n",
    "JSON databases return query results that can parse easily with little to no transformation. JavaScript and many other popular programming languages can parse these results. This ease of parsing reduces the amount of logic needed to build into the application layer.\n",
    "\n",
    "---\n",
    "\n",
    "## JSON Types\n",
    "\n",
    "Below is a list of data types **allowed** within JSON:\n",
    "\n",
    "- String\n",
    "- Number\n",
    "- Object (JSON object)\n",
    "- Array\n",
    "- Boolean\n",
    "- Null\n",
    "\n",
    "JSON values **cannot** be the following data types:\n",
    "\n",
    "- Function\n",
    "- Date\n",
    "- undefined\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Although <code>Date</code> data types cannot be used in JSON, their string representations can be, and are how dates are passed around in JSON. For example, \"2018-02-01\" (January 2, 2018) is acceptable in JSON and can be converted to a <code>Date</code> object.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "Now it's time for you to explore how JSON values will look.\n",
    "\n",
    "---\n",
    "\n",
    "### JSON String\n",
    "\n",
    "Strings in JSON _must be_ written within quotes:\n",
    "\n",
    "```json\n",
    "{ \"name\": \"Emily\" }\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### JSON Number\n",
    "\n",
    "Numbers in JSON _must be_ an integer and will **NOT** be wrapped in quotes:\n",
    "\n",
    "```json\n",
    "{ \"age\": 30 }\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### JSON Object\n",
    "\n",
    "JSON values can be objects. Remember that objects are like physical objects, like a car: many components make up the entire object.\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"customer\": {\n",
    "    \"firstName\": \"Carl\",\n",
    "    \"lastName\": \"Orff\",\n",
    "    \"age\": 75,\n",
    "    \"location\": \"Munich\"\n",
    "  }\n",
    "}\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### JSON Array\n",
    "\n",
    "JSON values can be arrays. Arrays are used to store multiple values within a single variable.\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"customers\": [\"Anna\", \"Mary\", \"Thomas\", \"Robert\", \"Tom\", \"Cora\"]\n",
    "}\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### JSON Boolean\n",
    "\n",
    "JSON values can be booleans. Booleans are values that are either set to be true or false.\n",
    "\n",
    "```json\n",
    "{ \"sale\": true }\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### JSON Null\n",
    "\n",
    "JSON values can also be Null. Null is a value that does not exist but prevents the field from being empty.\n",
    "\n",
    "```json\n",
    "{ \"middlename\": null }\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Relationships<a class=\"anchor\" id=\"DS108L6_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "# Relationships\n",
    "\n",
    "Data within MongoDB has something called a _flexible schema_. This term means that collections within a database do not enforce a specific data structure. How the data is modeled in the collection can affect the application's performance and database capacity. These are referred to as `embedded documents` and they are the best and most common way of structuring data in MongoDB.\n",
    "\n",
    "---\n",
    "\n",
    "## One-to-One Relationship\n",
    "\n",
    "Say you have customers in a collection, and you want to retrieve the address of a specific customer. In a normalized data model, it would look something like below:\n",
    "\n",
    "```json\n",
    "{\n",
    "   \"_id\": \"123\",\n",
    "   \"name\": \"Jeremy Houser\"\n",
    "}\n",
    "\n",
    "{\n",
    "   \"patron_id\": \"123\",\n",
    "   \"street\": \"1012 Grove Street\",\n",
    "   \"city\": \"Faketown\",\n",
    "   \"state\": \"CA\",\n",
    "   \"zip\": \"12345\"\n",
    "}\n",
    "```\n",
    "\n",
    "Above, you have two different sets of data that can be linked together using the id of \"123\". In NoSQL, the better way of organizing the data is to embed the address information within the same data set of the customer's name, like below:\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"_id\": \"123\",\n",
    "  \"name\": \"Jeremy Houser\",\n",
    "  \"address\": {\n",
    "    \"street\": \"1012 Grove Street\",\n",
    "    \"city\": \"Faketown\",\n",
    "    \"state\": \"CA\",\n",
    "    \"zip\": \"12345\"\n",
    "  }\n",
    "}\n",
    "```\n",
    "\n",
    "Now the address information of the customer is embedded and located in the same area as the name. Now you do not need to link two different sets of data together. This allows you to retrieve all of the data of this customer with only _one_ query.\n",
    "\n",
    "---\n",
    "\n",
    "## One-to-Many Relationship\n",
    "\n",
    "Say your above customer has multiple addresses. In a normalized data model, you would link the multiple addresses to the customer by using the customer's `_id`:\n",
    "\n",
    "```json\n",
    "{\n",
    "   \"_id\": \"123\",\n",
    "   \"name\": \"Jeremy Houser\"\n",
    "}\n",
    "\n",
    "{\n",
    "   \"patron_id\": \"123\",\n",
    "   \"street\": \"1012 Grove Street\",\n",
    "   \"city\": \"Faketown\",\n",
    "   \"state\": \"CA\",\n",
    "   \"zip\": \"12345\"\n",
    "}\n",
    "\n",
    "{\n",
    "   \"patron_id\": \"123\",\n",
    "   \"street\": \"8877 E. 1st Street\",\n",
    "   \"city\": \"Motown\",\n",
    "   \"state\": \"NY\",\n",
    "   \"zip\": \"09887\"\n",
    "}\n",
    "```\n",
    "\n",
    "Instead of the above, you can embed the multiple addresses as you did above. The difference when embedding multiple documents within one field is that they need to be contained within square brackets `[]`:\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"_id\": \"123\",\n",
    "  \"name\": \"Jeremy Houser\",\n",
    "  \"address\": [\n",
    "    {\n",
    "      \"patron_id\": \"123\",\n",
    "      \"street\": \"1012 Grove Street\",\n",
    "      \"city\": \"Faketown\",\n",
    "      \"state\": \"CA\",\n",
    "      \"zip\": \"12345\"\n",
    "    },\n",
    "    {\n",
    "      \"patron_id\": \"123\",\n",
    "      \"street\": \"8877 E. 1st Street\",\n",
    "      \"city\": \"Motown\",\n",
    "      \"state\": \"NY\",\n",
    "      \"zip\": \"09887\"\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "```\n",
    "\n",
    "Do you see how the addresses are within the square brackets `[]`? This data structure will allow you to pull in all of a specific customer's data with _one_ query.\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Make sure to notice that a comma (<code>,</code>) separates each address. This, along with square brackets (<code>[]</code>), is needed anytime a field in a document has multiple values or documents attached to it.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Many-to-Many Relationship\n",
    "\n",
    "There will come a time when you are working with a database, and referencing documents will be more efficient than embedding documents. This typically happens when working with a Many-to-Many Relationship. Consider the following example:\n",
    "\n",
    "```json\n",
    "{\n",
    "   \"_id\": \"123\",\n",
    "   \"name\": \"Jeremy Houser\",\n",
    "   \"address\": {\n",
    "        \"street\": \"1012 Grove Street\",\n",
    "        \"city\": \"Faketown\",\n",
    "        \"state\": \"CA\",\n",
    "        \"zip\": \"12345\"\n",
    "   },\n",
    "   \"supportRep\": [\n",
    "       {\n",
    "            \"_id\": 2435,\n",
    "            \"title\": \"Support Manager\",\n",
    "            \"location\": \"MA\"\n",
    "        },\n",
    "        {\n",
    "            \"_id\": 3829,\n",
    "            \"title\": \"Support Representative\",\n",
    "            \"location\": \"NY\"\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "\n",
    "{\n",
    "   \"_id\": \"443\",\n",
    "   \"name\": \"Alison Markson\",\n",
    "   \"address\": {\n",
    "        \"street\": \"664 Central Street\",\n",
    "        \"city\": \"Blurg\",\n",
    "        \"state\": \"MO\",\n",
    "        \"zip\": \"87469\"\n",
    "   },\n",
    "   \"supportRep\": [\n",
    "       {\n",
    "            \"_id\": 2435,\n",
    "            \"title\": \"Support Manager\",\n",
    "            \"location\": \"MA\"\n",
    "        },\n",
    "        {\n",
    "            \"_id\": 3829,\n",
    "            \"title\": \"Support Representative\",\n",
    "            \"location\": \"NY\"\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "```\n",
    "\n",
    "Above, you have _two_ different customers with the same _two_ support representatives. In each case, you include all of the information of the same support representatives within each customer. This is allowing for repetition, which you do not want. To prevent that, you can have a collection that stores the data of all the support representatives, along with your collection of customers. You can then reference the support representatives' collection:\n",
    "\n",
    "```json\n",
    "// SupportRep collection\n",
    "[\n",
    "    {\n",
    "        \"_id\": 2435,\n",
    "        \"title\": \"Support Manager\",\n",
    "        \"location\": \"MA\"\n",
    "    },\n",
    "    {\n",
    "        \"_id\": 3829,\n",
    "        \"title\": \"Support Representative\",\n",
    "        \"location\": \"NY\"\n",
    "    }\n",
    "]\n",
    "\n",
    "\n",
    "// Customer collection\n",
    "{\n",
    "   \"_id\": \"123\",\n",
    "   \"name\": \"Jeremy Houser\",\n",
    "   \"address\": {\n",
    "        \"street\": \"1012 Grove Street\",\n",
    "        \"city\": \"Faketown\",\n",
    "        \"state\": \"CA\",\n",
    "        \"zip\": \"12345\"\n",
    "   },\n",
    "   \"supportRep_id\": [2435, 3829];\n",
    "}\n",
    "\n",
    "{\n",
    "   \"_id\": \"443\",\n",
    "   \"name\": \"Alison Markson\",\n",
    "   \"address\": {\n",
    "        \"street\": \"664 Central Street\",\n",
    "        \"city\": \"Blurg\",\n",
    "        \"state\": \"MO\",\n",
    "        \"zip\": \"87469\"\n",
    "   },\n",
    "   \"supportRep_id\": [2435, 3829];\n",
    "}\n",
    "```\n",
    "\n",
    "You store the support representative's `_id` within each customer so that both `supportReps` are easily found and referenced.\n",
    "\n",
    "Great! Now that you understand the data structure in MongoDB, it is time to explore how to insert documents into your database.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Inserting Documents<a class=\"anchor\" id=\"DS108L6_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00157ac3-4168-45a3-bc72-37ffce044310",
   "metadata": {},
   "source": [
    "# Inserting Documents\n",
    "\n",
    "Earlier in this lesson, you learned what documents look like within a MongoDB collection. Each document has a field and a value. That value can then be an embedded document if needed.\n",
    "\n",
    "---\n",
    "\n",
    "## Insert a Single Document\n",
    "\n",
    "Before inserting documents, make sure you have a playground up, running, and connected to your database.\n",
    "\n",
    "To insert a single document into a collection, you would use `insertOne()`. The generic syntax for inserting is as follows:\n",
    "\n",
    "```text\n",
    "db.collectionName.insertOne([document_schema])\n",
    "```\n",
    "\n",
    "The `[document_schema]` is the document itself and includes the fields and values separated by commas (`,`) within curly braces (`{}`). When inserting documents, you must make sure that each document has a unique identifier, usually an `_id`. MongoDB will automatically create one for you if you insert a document without an `_id` field. If you would not like to do that, you can identify the document ID yourself. You **MUST** make sure that the documentID does not already exist, or you will have an error thrown when you try to run the insert. Since your `appusers` collection is empty, you should add a new user to your collection, as shown below:\n",
    "\n",
    "```text\n",
    "db.appusers.insertOne({_id:1,lastName:\"Pumpernickel\", firstName:\"Georgina\", middleName:\"Sasquatch\", age:27, gender:\"f\"})\n",
    "```\n",
    "\n",
    "Go ahead and run the above query in the playground. Other than the fact that poor Georgina has an unfortunate name, you should have also noticed the addition of the `_id` field, and you’ve assigned it a value of 1. This will succeed, and MongoDB will return an `\"acknowledged\" : true message`, with an `\"insertedId\" : 1` along with it. The critical part here is to make sure that you don’t duplicate when you specify the ID yourself, or your insert will fail. If you want to be sure that your data insert will succeed, you can let MongoDB generate that unique value for you and use the value that it provides in your code moving forward.\n",
    "\n",
    "Now add another user, leveraging the flexible schema you learned about earlier:\n",
    "\n",
    "```text\n",
    "db.appusers.insertOne({_id:2,lastName:\"Wilson\", firstName:\"Coderboy\", age:18, favoriteColor:\"blue\"})\n",
    "```\n",
    "\n",
    "You should run this command and get the same acknowledgment message as before, except this time you will see that the `InsertedId` is 2. Notice the differences: Georgina has a middle name and gender specified, while Coderboy does not - yet Coderboy has a favorite color specified. Ideally, you’d have an initial set of fields that you would deem acceptable as entries into your \"persons\" documents, and a subset of those are what you would be populating. This will be important later as you create indexes in your MongoDB database.\n",
    "\n",
    "Now, if you want to see all documents within your database, you can run a query to see both of your documents. See below:\n",
    "\n",
    "```text\n",
    "db.appusers.find({})\n",
    "```\n",
    "\n",
    "The above query will find all documents within the `appusers` collection. You should now see both documents you have inserted and all of the fields included.\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You will be exploring more of what you can do with the <code>.find()</code> query in the next lesson.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Inserting Many Documents\n",
    "\n",
    "The `.insertMany()` query is the companion to insertOne, where you can insert several documents into the same collection at once. The syntax is somewhat similar:\n",
    "\n",
    "```text\n",
    "db.collectionName.insertMany( [ {document1}, {document2}, … {documentN}])\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>When inserting many documents, all documents must be within square brackets <code>[]</code> for the insert query to run correctly.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "The specification of having an `_id` field or not will work exactly the same as the insertOne command. You can specify one if you want, but make sure that it’s not already in use. Now add a few more rows to your original `appusers` collection, and see how this works:\n",
    "\n",
    "```text\n",
    "db.appusers.insertMany([{lastName: \"Anstruther\", firstName: \"Jimmy\", age: 21}, {lastName: \"Stevens\", firstName: \"Amelia\", age: 28},{lastName: \"Hopkins\", firstName: \"Fred\", age: 35, favoriteColor: \"Green\"}])\n",
    "```\n",
    "\n",
    "Notice how the last document has an extra field \"favoriteColor\" that the first two documents in the query do not have. Also, you did not include id's for the three new users like you did with the first two users added. Because of the flexible schema, you can do this. Go ahead and run the above query. You should get the following message:\n",
    "\n",
    "```js\n",
    "{\n",
    "  \"acknowledged\": true,\n",
    "  \"insertedIds\": {\n",
    "    \"0\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd6\"\n",
    "    },\n",
    "    \"1\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd7\"\n",
    "    },\n",
    "    \"2\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd8\"\n",
    "    }\n",
    "  }\n",
    "}\n",
    "```\n",
    "\n",
    "Again, run the `find` query to see all of your documents:\n",
    "\n",
    "```text\n",
    "db.appusers.find({})\n",
    "```\n",
    "\n",
    "Look carefully at the returned documents. The `_id` field that you created will now have the `$oid` value that was automatically created when the documents were inserted. You should see something similar to the code below, but your `$oid` values may be different:\n",
    "\n",
    "```js\n",
    "  {\n",
    "    \"_id\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd6\"\n",
    "    },\n",
    "    \"lastName\": \"Anstruther\",\n",
    "    \"firstName\": \"Jimmy\",\n",
    "    \"age\": 21\n",
    "  },\n",
    "  {\n",
    "    \"_id\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd7\"\n",
    "    },\n",
    "    \"lastName\": \"Stevens\",\n",
    "    \"firstName\": \"Amelia\",\n",
    "    \"age\": 28\n",
    "  },\n",
    "  {\n",
    "    \"_id\": {\n",
    "      \"$oid\": \"6102f0fc086d5ec1c2162cd8\"\n",
    "    },\n",
    "    \"lastName\": \"Hopkins\",\n",
    "    \"firstName\": \"Fred\",\n",
    "    \"age\": 35,\n",
    "    \"favoriteColor\": \"Green\"\n",
    "  }\n",
    "```\n",
    "\n",
    "Now that you have gone through plenty of inserting, return to your `Collections` tab in Atlas. Refresh the page, and you should see that your `appusers` collection now has five documents. You can click on the collection and see each document and the fields and values included.\n",
    "\n",
    "---\n",
    "\n",
    "## Create Collection When Inserting\n",
    "\n",
    "You've seen how to use the `db.createCollection` function to create a collection, but there is a shortcut. If you run an insert query with a collection name that does not already exist, it will automatically create that collection for you. Time to try it!\n",
    "\n",
    "Run the following query:\n",
    "\n",
    "```text\n",
    "db.movies.insertMany([{title: \"The Shawshank Redemption\", director: \"Frank Darabont\", yearReleased: 1994}, {title: \"The Dark Knight\", director: \"Christopher Nolan\", yearReleased: 2008}, {title: \"It's a Wonderful Life\", director: \"Frank Capra\", yearReleased: 1946}])\n",
    "```\n",
    "\n",
    "You should get the `\"acknowledged\" : true` message. If you go into Atlas again, you will see a collection called `movies` with three documents.\n",
    "\n",
    "Great work during this lesson! Time for you to do a lesson review of the key terms and then jump into your first MongoDB project."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7e6778a-158a-419b-b4f9-880dad5502f9",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Key Terms<a class=\"anchor\" id=\"DS108L6_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e0ff15b-993e-4b35-a5c9-37cd2e04f438",
   "metadata": {},
   "source": [
    "# Key Terms\n",
    "\n",
    "Below is a list of a short description of the important keywords you have learned in this lesson. Please read through and go back and review any concepts you don't fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Term</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Atlas</td>\n",
    "        <td>Cloud database management.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Collection</td>\n",
    "        <td>A grouping of MongoDB documents within a database.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>JSON</td>\n",
    "        <td>JavaScript Object Notation (JSON) is an open, human and machine-readable standard that facilitates data interchange</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>JSON types</td>\n",
    "        <td>String, Number, Object (JSON object), Array, Boolean, Null</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Relationships</td>\n",
    "        <td>One-to-One, One-to-Many, Many-to-Many</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>db.collectionName.insertOne({document})</td>\n",
    "        <td>Inserts one document into the collection defined.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>db.collectionName.insertMany([{document1}, {document2}, ...])</td>\n",
    "        <td>Inserts many documents into the collection defined.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>field</td>\n",
    "        <td>Part of the document that includes the different data for that particular document.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>db.collectionName.find({})</td>\n",
    "        <td>A basic query that will find all documents within a collection.</td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80643e1d-267b-4caa-8a5d-9bb0fa4a507a",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Lesson 1 Practice Hands-On<a class=\"anchor\" id=\"DS108L6_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e41ccc3a-bfba-4ee2-8463-117de6377df3",
   "metadata": {},
   "source": [
    "For your Lesson 1 Practice Hands-On, you will be working with your new knowledge on NoSQL. `This Hands-On will not be graded`, but we encourage you to complete it. The best way to become great at working with databases is to practice! Once you have submitted your project, you will be able to access the solution on the next page.\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This Hands-On is structured into _two_ parts, and each part may ask you to run multiple queries. After each query, please take a screenshot and add it to a text document (or an equivalent) and name this file `NoSQL-HandsOn1`. This way, you will be able to submit your answers to each part all at once. You will continue working with the `appusers` collection in Atlas that you created during the lesson. Good luck! \n",
    "\n",
    "---\n",
    "\n",
    "## Part 1\n",
    "\n",
    "1. Create three more users of your choosing, using the `insertOne()` query, and add them to the `appusers` collection.\n",
    "    - Include at least the `firstName`, `lastName`, and `age` fields. Feel free to also include any other fields you think would be useful data for an app user.\n",
    "\n",
    "        <div class=\"panel panel-danger\">\n",
    "        <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "        </div>\n",
    "        <div class=\"panel-body\">\n",
    "        <p>Please take a screenshot of each query you run (since you are inserting each user one-by-one using <code>insertOne()</code>, you will run at least three queries) and save it to your <code>NoSQL-HandsOn1</code> text document.</p>\n",
    "        </div>\n",
    "        </div>\n",
    "\n",
    "2. Next, run a basic `find()` query to see all of your documents within your database through the Mongo Shell.\n",
    "\n",
    "---\n",
    "\n",
    "## Part 2\n",
    "\n",
    "1. Create a new collection within your database through Atlas. \n",
    "    - This new collection should be named `cars`. \n",
    "2. Insert five cars into this collection using the `insertMany()` query. \n",
    "    - Include the following fields: `make`, `model`, `color`, `year`, `fourDoor`, and `fourWheelDrive`. \n",
    "        - The last two fields, `fourDoor` and `fourWheelDrive`, should be of type Boolean (i.e. true or false). \n",
    "3. Once that is done, run a `find()` query to see your newly created documents. \n",
    "4. Lastly, return to Atlas and view your collection and documents there.\n",
    "\n",
    "    <div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "    <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "    <p>Be sure to take screenshots of each of your queries.</p>\n",
    "    </div>\n",
    "    </div>\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your <code>NoSQL-HandsOn1</code> text document when finished! You will not be able to re-submit, so be sure the screenshots to each part are located within this document.</p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26279ed2-b15d-49c9-9508-03c2540d28b1",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 13 - Practice Hands-On solution<a class=\"anchor\" id=\"DS108L6_page_13\"></a>\n",
    "\n",
    "[Back to Top](#DS108L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07b4d9af-003b-4834-9c49-f5aa68084da9",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3d789c63-4cc7-4cd7-a6e9-67de53618572",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Solution\n",
    "\n",
    "Below is the solution for your Lesson 1 Practice Hands-On.\n",
    "\n",
    "---\n",
    "\n",
    "## Part 1\n",
    "\n",
    "```text\n",
    "// query 1\n",
    "\n",
    "db.appusers.insertOne({firstName:\"Bart\", lastName:\"Collins\", age:47})\n",
    "db.appusers.insertOne({firstName:\"Winston\", lastName:\"Lupin\", age:33})\n",
    "db.appusers.insertOne({firstName:\"Brandon\", lastName:\"Smith\", age:65})\n",
    "\n",
    "// query 2\n",
    "\n",
    "db.appusers.find({})\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Part 2\n",
    "\n",
    "```text\n",
    "// query 1\n",
    "\n",
    "db.cars.insertMany([\n",
    "    {make: \"Volkswagen\", model: \"Golf\", color: \"Red\", year: \"2011\", fourDoor: true, fourWheelDrive: false},\n",
    "    {make: \"Toyota\", model: \"Tundra\", color: \"Super White\", year: \"2018\", fourDoor: true, fourWheelDrive: true},\n",
    "    {make: \"Jeep\", model: \"Wagoneer\", color: \"Copper Brown Metallic\", year: \"1982\", fourDoor: true, fourWheelDrive: true},\n",
    "    {make: \"Jaguar\", model: \"XJ6 Sovereign\", color: \"Brown\", year: \"1986\", fourDoor: true, fourWheelDrive: false},\n",
    "    {make: \"Kia\", model: \"Rio LX\", color: \"Clear White\", year: \"2018\", fourDoor: true, fourWheelDrive: false}\n",
    "])\n",
    "\n",
    "// query 2\n",
    "\n",
    "db.cars.find({})\n",
    "```"
   ]
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}