Merge pull request #1 from ReCoded-Org/dbmodule

Module 2: Databases

Author: Shrreya

module2-database-technologies/README.md

@@ -0,0 +1,18 @@
+## Introduction to Databases
+
+In this module, you'll learn about **databases**. Database is a general term
+that refers to the data stored in a structured format. We use databases when we
+want to persist data for future use. For example, in a web application, when a
+user writes something in a text box, this data will be lost when the page is
+refreshed -- unless this data is persisted in a database.
+
+Databases are a ubiquitous and foundational part of backend technology. One
+would use databases instead of local storage or cookies, for example, when the
+information being persisted needs to be available to any possible client. For
+example, information stored in [local
+storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) is not automatically synchronized
+across browsers. For example, if you were to store information about user
+settings in local storage, then those settings would no longer be available on a
+different browser -- but if you store them in a database, the user can access
+them from any client.
+

module2-database-technologies/assets/many-to-many.png

@@ -0,0 +1,59 @@
+# Introduction to relational databases
+
+One of the most common types of databases is the **relational database**. A
+relational database stores data in tables, and these tables may have *relations*
+to one another. For example, you may have a table `Customer`; each row
+represents a customer in your application. You may have another table 
+`Order`, a customer can order many things, and each order will appear in this
+table. We will later look in more detail at how the two tables are linked.
+
+Relational databases are frequently referred to as SQL databases. SQL
+(Structured Query Language) is a
+[declarative programming
+language](https://365datascience.com/tutorials/sql-tutorials/sql-declarative-language/)
+that is commonly used to query for data. Not all relational databases
+necessarily use SQL, but it is by far the most common, so in practice, SQL
+database and relational database are synomyous terms.
+
+The most frequently used relational databases are PostgreSQL and MySQL. There
+are many offerings for SQL databases, and each may have slightly different
+syntax for SQL. However, if you understand the general concept of relational
+databases, you will be able to easily use different databases. 
+
+### Understanding relational database structure
+As mentioned previously, data in relational databases are usually organized in a
+tabular format, similar to spreadsheets.
+
+* A database has many tables
+* A table has many rows (also known as records)
+* A row has many columns (also known as fields).
+
+For example, the previously mentioned `Customer` table may look something like
+the following. Note that this is not any particular syntax but simply a
+visualization of the data.
+
+**id**|**first\_name**|**last\_name**|**registered\_at**
+:-----:|:-----:|:-----:|:-----:
+1|Joe|Smith|2012-01-02
+2|Jane|Doe|2012-01-03
+3|Susan|Stone|2012-01-05
+
+The `Order` table may look something like so:
+
+**id**|**product**|**delivered**|**customer\_id**
+:-----:|:-----:|:-----:|:-----:
+1|Keyboard|TRUE|1
+2|Mouse|FALSE|1
+3|Cookies|TRUE|1
+4|Rice|TRUE|2
+
+On the `Order` table, note that there is a field called `customer_id`. This is
+called a **foreign key** (or sometimes join key). This column creates a
+**relation** between the `Customer` and `Order` tables: it tells us to which
+customer the order belongs. This is the core of relational databases: expressing
+relations between entities.
+
+This table says that Joe has ordered a keyboard, mouse, and cookies. He has
+three orders, because there are three rows with `customer_id = 1`. Jane has ordered one item: rice (`customer_id = 2`).
+
+

module2-database-technologies/assets/one-to-many.png

@@ -0,0 +1,30 @@
+### Understanding Relational Database Structure
+We usually use the terms one-to-many and many-to-many to describe
+relationships between tables. 
+
+For example, a customer may have multiple orders. This is a one-to-many relationship,
+since one customer has many orders. It should be noted that the foreign key goes
+on the side that is "many". In the example above, note that the `customer_id`
+key is located on the `Order` table.
+
+[![One to many relationship](../assets/one-to-many.png)](https://fmhelp.filemaker.com/help/18/fmp/en/index.html#page/FMP_Help/one-to-many-relationships.html)
+
+For a many-to-many relationship, consider students and courses at a university.
+A student can take many courses; a course also has many students. Many-to-many
+relationships are [expressed slightly
+differently](https://dzone.com/articles/how-to-handle-a-many-to-many-relationship-in-datab) than using a single foreign key.
+
+To express a many-to-many relationship between two tables, we create a third
+table that contains the foreign keys of the two tables being connected. For
+example, the diagram below connects classes and students together through a
+table called `Enrollments`. Each row in `Enrollments` represents one class that
+one student is taking; there can be multiple such entries in the table.
+
+[![Many to many
+relationship](../assets/many-to-many.png)](https://fmhelp.filemaker.com/help/18/fmp/en/index.html#page/FMP_Help%2Fmany-to-many-relationships.html%23)
+
+See this [StackOverflow
+question](https://stackoverflow.com/questions/4601703/difference-between-one-to-many-and-many-to-one-relationship)
+for more details.
+
+

module2-database-technologies/r1-introduction-to-databases/README.md

@@ -0,0 +1,68 @@
+# SQL queries
+
+Now that we understand the general concept behind relational data, how do we
+query it? Note that every SQL database may have slightly different syntax in
+terms of quotations, capitalization, commas, etc., so be sure to check. In these
+examples, we will be using MySQL.
+
+Suppose you have an existing MySQL database. To create the `customer` table (we
+will now lowercase the table names by convention), you would use the `CREATE
+TABLE` statement. Note that every column has a data type and can also be given additional definition rules.
+
+[`AUTO_INCREMENT`](https://www.guru99.com/auto-increment.html) is used to
+automatically generated the IDs; when inserting a row, you do not need to
+provide the ID, it is automatically generated by incrementing the previous ID. We will see this in our example queries later. `NOT NULL` means that the user cannot provide a `NULL` value for values in this column. `PRIMARY KEY` is used to denote a column as the primary key field, and it is often used in conjunction with `AUTO INCREMENT` for databases with numeric IDs.
+
+There are many options when creating columns. Refer to the `CREATE TABLE` [documentation](https://dev.mysql.com/doc/refman/8.0/en/create-table.html).
+```sql
+CREATE TABLE IF NOT EXISTS customer (
+    task_id INT AUTO_INCREMENT PRIMARY KEY,
+    first_name VARCHAR(255) NOT NULL,
+    last_name VARCHAR(255) NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)  
+```
+
+We can now add some data using `INSERT INTO`. Note that we do not need to
+manually provide an id or a created timestamp, these are automatically generated
+by MySQL.
+
+```sql
+INSERT INTO customer (first_name, last_name) VALUES ('Jane', 'Doe');
+INSERT INTO customer (first_name, last_name) VALUES ('Joe', 'Smith');
+```
+
+Now let's `SELECT` the data -- that is, let's view the data.
+```sql
+SELECT * FROM customer;
+```
+
+The `*` symbol tells us to get all columns. You should see something like this:
+
+```
+ id | first_name | last_name |          created_at
+----+------------+-----------+-------------------------------
+  1 | Jane      | Doe     | 2021-08-29 03:33:14.559122-07
+  2 | Joe      | Smith   | 2021-08-29 03:34:08.522222-07
+(1 row)
+```
+
+However, you could select only certain columns by typing the name of the column:
+```sql
+SELECT first_name FROM customer;
+```
+
+Finally, let's create a table with a foreign key, the `order` table, noting the
+syntax that is used to create a foreign key that references our `customer`
+table.
+
+```sql
+CREATE TABLE student (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  product VARCHAR(255) NOT NULL,
+  delivered BOOL,
+  customer_id INT FOREIGN KEY REFERENCES customer(id)
+);
+```
+
+

module2-database-technologies/r2-introduction-to-relational-databases/README.md

@@ -0,0 +1,32 @@
+# Joins
+
+**Join** refers to the process of combining two tables together based on a
+common column. In this case, for example, if we want to answer, in one query,
+the question: what did Ammar order? We would write a query like so:
+
+```
+SELECT product FROM order INNER JOIN customers on orders.customer_id =
+customer.id WHERE customer.id = 2;
+```
+
+On your own, try running only the first part of this query and see what happens.
+In your own words, what does this give you?
+
+```
+SELECT product FROM order INNER JOIN customers on orders.customer_id;
+```
+
+You can read more about [SQL
+joins](https://www.educative.io/blog/what-are-sql-joins) here. There are many
+types of joins, but an inner join will by far the most common one.
+
+
+### Further resources for SQL
+* [This repository](https://github.com/LambdaSchool/Relational-Databases) provides
+a good additional resource for reviewing SQL databases and some common parts of
+the query language.
+* When in doubt, you can simply Google, for example, "how to select in MySQL" and check
+    StackOverflow.
+
+
+

module2-database-technologies/r2.1-understanding-relational-database-structure/README.md

@@ -0,0 +1,25 @@
+# Introduction to NoSQL databases
+In the past decade, **NoSQL** databases have become a popular way to store
+databases.
+There are multiple types of NoSQL databases, the most common being:
+* **Document**: stores data similar to JSON
+* **Key-value**: data is stored as a pair of key-values, with each value having
+    a unique key that identifies it
+* **Graph databases**: used to store data that is represented well by the graph
+    data structure (see the later section on neo4j)
+
+## When to use SQL vs NoSQL
+Generally speaking, you will want to use SQL databases when your data is highly
+structured. SQL databases enforce a rigid structure, which is
+generally a good thing for type safety, documentation, and so on.
+
+However, sometimes,
+it may be faster or more convenient not to adhere to such a rigid structure.
+This is one of the reasons that NoSQL database have emerged in popularity.
+
+When operating at scale, SQL and NoSQL also have some differences, with SQL
+primarily being more robust when it comes to potential invalid or failed
+transactions. You can read more about this topic
+[here](https://www.imaginarycloud.com/blog/sql-vs-nosql/#Structure).
+
+

module2-database-technologies/r2.2-sql-queries/README.md

@@ -0,0 +1,36 @@
+# Introduction to MongoDB
+[MongoDB](https://www.mongodb.com/) is the most popular NoSQL database, and it
+is considered a document database. MongoDB is generally considered very
+straightforward to use, because working with it is very similar to working with
+JSON, which many web developers are familiar with.
+
+### General Mongo Concepts
+In MongoDB, a database has many collections. A collection has many documents (a
+collection can be considered the equivalent of a table in a relational database). A
+document is similar to what we know normally as JSON.
+
+An example of a document, as taken from the Mongo docs, would look like the
+below. Note that the [_id field is present on each
+document](https://docs.mongodb.com/manual/core/document/#the-_id-field).
+```
+{
+   _id: 'some_id',
+   field1: value1,
+   field2: value2,
+   field3: value3,
+   ...
+   fieldN: valueN
+}
+```
+
+See the [official
+documentation on collections](https://docs.mongodb.com/manual/core/databases-and-collections/)
+and [the official documentation on
+documents](https://docs.mongodb.com/manual/core/document/) for further reference.
+
+### JavaScript 
+To get started with MongoDB, you'll want to [follow the tutorial on the
+official
+documentation](https://www.mongodb.com/blog/post/quick-start-nodejs-mongodb--how-to-get-connected-to-your-database) for the Node.js client. Please be sure to follow the setup on this page before trying the examples.
+
+