html-flip-book-react 0.0.0-alpha.1

package/example/assets/pages_data/en/content/007-order-and-group-by.md

@@ -0,0 +1,142 @@
+# Sorting with ORDER and GROUP BY
+
+In the last chapter, you've learned how to use the `SELECT` statement with the `WHERE` clause and filter the result set based on some conditions.
+
+More often than not, you would want to order the results in a specific way based on a particular column. For example, you might want to order the users alphabetically, based on their username.
+
+In this chapter, you will learn how to use the `ORDER BY` and `GROUP BY` clauses.
+
+## ORDER BY
+
+The main thing that you need to keep in mind when using `ORDER BY` is to specify the column or columns you want to order by. In case that you want to specify multiple columns to order by, you need to separate each column with a comma.
+
+If we were to run the following statement without providing an `ORDER BY` clause:
+
+```sql
+SELECT id, username FROM users;
+```
+
+We will get the following output:
+
+```
++----+----------+
+| id | username |
++----+----------+
+|  2 | bobby    |
+|  3 | devdojo  |
+|  4 | tony     |
+|  5 | bobby    |
+|  6 | devdojo  |
+|  7 | tony     |
++----+----------+
+```
+
+As you can see, the result set is sorted by the primary key, which in our case is the `id` of each user. If we wanted to sort the output by `username`, we would run the following query:
+
+```sql
+SELECT id, username FROM users ORDER BY username;
+```
+
+> Note: The `ORDER BY` statement is followed by the column's name that we want to order by.
+
+The output, in this case, will be:
+
+```
++----+----------+
+| id | username |
++----+----------+
+|  2 | bobby    |
+|  5 | bobby    |
+|  3 | devdojo  |
+|  6 | devdojo  |
+|  4 | tony     |
+|  7 | tony     |
++----+----------+
+```
+
+> Note: You can use `ORDER BY` with and without specifying a `WHERE` clause. If you've used a `WHERE` clause, you need to put the `ORDER BY` clause after the `WHERE` clause.
+
+The default sorting is ascending and is specified with the `ASC` keyword, and you don't need to add it explicitly, but if you want to sort by descending order, you need to use the `DESC` keyword.
+
+If we use the query above and add `DESC` at the end as follows:
+
+
+```sql
+SELECT id, username FROM users ORDER BY username DESC;
+```
+
+We will see the following output:
+
+```
++----+----------+
+| id | username |
++----+----------+
+|  4 | tony     |
+|  7 | tony     |
+|  3 | devdojo  |
+|  6 | devdojo  |
+|  2 | bobby    |
+|  5 | bobby    |
++----+----------+
+```
+
+As you can see, we've got the same list of users sorted alphabetically but in reverse order.
+
+## GROUP BY
+
+The `GROUP BY` statement allows you to use a function like `COUNT`, `MIN`, `MAX` etc., with multiple columns.
+
+For example, let's say that we wanted to get all of the counts of all users grouped by username.
+
+In our case, we have two users with username `bobby`, two users with username `tony`, and two users with username `devdojo`. This represented in an SQL statement would look like this:
+
+```sql
+SELECT COUNT(username), username FROM users GROUP BY username;
+```
+
+The output, in this case, would be:
+
+```
++-----------------+----------+
+| COUNT(username) | username |
++-----------------+----------+
+|               2 | bobby    |
+|               2 | devdojo  |
+|               2 | tony     |
++-----------------+----------+
+```
+
+The `GROUP BY` statement grouped the identical usernames. Then it ran a `COUNT` on each of `bobby`, `tony` and `devdojo`.
+
+The main thing to remember here is that the `GROUP BY` should be added after the `FROM` clause and after the `WHERE` clause.
+
+## HAVING Clause
+
+The `HAVING` clause allows you to filter out the results on the groups formed by the `GROUP BY` clause.
+
+For example, let's say that we wanted to get all usernames that are duplicates, i.e., all the usernames present in more than one table record.
+
+In our case, we have two users with username `bobby`, two users with username `tony`, and two users with username `devdojo`. This represented in an SQL statement would look like this:
+
+```sql
+SELECT COUNT(username), username
+FROM users
+GROUP BY username
+HAVING COUNT(username) > 1;
+```
+
+The output, in this case, would be:
+
+```
++-----------------+----------+
+| COUNT(username) | username |
++-----------------+----------+
+|               2 | bobby    |
+|               2 | devdojo  |
+|               2 | tony     |
++-----------------+----------+
+```
+
+The `GROUP BY` clause grouped the identical usernames, calculated their counts and filtered out the groups using the `HAVING` clause.
+
+> **NOTE** :- _The WHERE clause places conditions on the selected columns, whereas the HAVING clause places conditions on groups created by the GROUP BY clause._

package/example/assets/pages_data/en/content/008-insert.md

@@ -0,0 +1,86 @@
+# INSERT
+
+To add data to your database, you would use the `INSERT` statement. You can insert data into one table at a time only.
+
+The syntax is the following:
+
+```sql
+INSERT INTO table_name
+  (column_name_1,column_name_2,column_name_n)
+VALUES
+  ('value_1', 'value_2', 'value_3');
+```
+
+You would start with the `INSERT INTO` statement, followed by the table that you want to insert the data into. Then you would specify the list of the columns that you want to insert the data into. Finally, with the `VALUES` statement, you specify the data that you want to insert.
+
+> The important part is that you need to keep the order of the values based on the order of the columns that you've specified.
+
+In the above example the `value_1` would go into `column_name_1`, the `value_2` would go into `column_name_2` and the `value_3` would go into `column_name_x`.
+
+Let's use the table that we created in the last chapter and insert 1 user into our `users` table:
+
+```sql
+INSERT INTO users
+  (username, email, active)
+VALUES
+  ('greisi', 'g@devdojo.com', true);
+```
+
+Rundown of the insert statement:
+
+* `INSERT INTO users`: First, we specify the `INSERT INTO` keywords which tells MySQL that we want to insert data into the `users` table.
+* `users (username, email, active)`: Then, we specify the table name `users` and the columns that we want to insert data into.
+* `VALUES`: Then, we specify the values that we want to insert in.
+
+## Inserting multiple records
+
+We've briefly covered this in one of the previous chapters, but in some cases, you might want to add multiple records in a specific table.
+
+Let's say that we wanted to create 5 new users, rather than running 5 different queries like this:
+
+```sql
+INSERT INTO users (username, email, active) VALUES ('user1', 'user1@devdojo.com', true);
+INSERT INTO users (username, email, active) VALUES ('user1', 'user2@devdojo.com', true);
+INSERT INTO users (username, email, active) VALUES ('user1', 'user3@devdojo.com', true);
+INSERT INTO users (username, email, active) VALUES ('user1', 'user4@devdojo.com', true);
+INSERT INTO users (username, email, active) VALUES ('user1', 'user5@devdojo.com', true);
+```
+
+What you could do is to combine this into one `INSERT` statement by providing a list of the values that you want to insert as follows:
+
+```sql
+INSERT INTO users
+  (username, email, active)
+VALUES
+  ('user1', 'user1@devdojo.com', true),
+  ('user2', 'user2@devdojo.com', true),
+  ('user3', 'user3@devdojo.com', true),
+  ('user4', 'user4@devdojo.com', true),
+  ('user5', 'user5@devdojo.com', true);
+```
+
+That way, you will add 5 new entries in your `users` table with a single `INSERT` statement. This is going to be much more efficient.
+
+## Inserting multiple records using another table
+
+In the previous section, we have discussed how we can insert multiple records using a single INSERT query.
+But sometimes there are cases where we need to insert multiple records which are residing in some other table.
+
+In this section, we are going to learn how we can insert multiple records at once using a single INSERT query.
+
+Consider a table, say `prospect_users`, which stores the information of the people who want to become the users of our service, but they are not yet actual users.
+
+In order to add them to our user database, we have to insert there entries into our `users` table.
+We can achieve the same by writing an `INSERT` query with multiple `VALUES` listed in them (as discussed in previous section).
+
+But there is an easier way where we achieve the same by querying the `prospect_users` table.
+
+
+```sql
+INSERT INTO users (username, email, active)
+SELECT username, email, active
+FROM prospect_users
+WHERE active=true;
+```
+
+Using the above statement, an entry for each active prospect users will be made in our `users` table.

package/example/assets/pages_data/en/content/009-update.md

@@ -0,0 +1,92 @@
+# UPDATE
+
+As the name suggests, whenever you have to update some data in your database, you would use the `UPDATE` statement.
+
+You can use the `UPDATE` statement to update multiple columns in a single table.
+
+The syntax would look like this:
+
+```sql
+UPDATE users SET username='bobbyiliev' WHERE id=1;
+```
+
+Rundown of the statement:
+
+* `UPDATE users`: First, we specify the `UPDATE` keyword followed by the table that we want to update.
+* `username='bobbyiliev'`: Then we specify the columns that we want to update and the new value that we want to set.
+* `WHERE id=1`: Finally, by using the `WHERE` clause, we specify which user should be updated. In our case, it is the user with ID 1.
+
+The most important thing that you need to keep in mind is that if you don't specify a `WHERE` clause, all of the entries inside the `users` table would be updated, and all users would have the `username` set to `bobbyiliev`.
+
+> Important: You need to be careful when you use the `UPDATE` statement without a `WHERE` clause as every single row will be updated.
+
+If you have been following along all of the user entries in our `users` table, it currently have no data in the `about` column:
+
+```
++----+----------+-------+
+| id | username | about |
++----+----------+-------+
+|  2 | bobby    | NULL  |
+|  3 | devdojo  | NULL  |
+|  4 | tony     | NULL  |
+|  5 | bobby    | NULL  |
+|  6 | devdojo  | NULL  |
+|  7 | tony     | NULL  |
++----+----------+-------+
+```
+
+Let's go ahead and update this for all users and set the column value to `404 bio not found`, For example:
+
+```sql
+UPDATE users SET about='404 bio not found';
+```
+
+The output would let you know how many rows have been affected by the query:
+
+```
+Query OK, 6 rows affected (0.02 sec)
+Rows matched: 6  Changed: 6  Warnings: 0
+```
+
+Now, if you were to run a select for all `users`, you would get the following result:
+
+```
++----+----------+-------------------+
+| id | username | about             |
++----+----------+-------------------+
+|  2 | bobby    | 404 bio not found |
+|  3 | devdojo  | 404 bio not found |
+|  4 | tony     | 404 bio not found |
+|  5 | bobby    | 404 bio not found |
+|  6 | devdojo  | 404 bio not found |
+|  7 | tony     | 404 bio not found |
++----+----------+-------------------+
+```
+
+Let's now say that we wanted to update the `about` column for the user with an id of 2. In this case, we need to specify a `WHERE` clause followed by the ID of the user that we want to update as follows:
+
+```sql
+UPDATE users SET about='Hello World :)' WHERE id=2;
+```
+
+The output here should indicate that only 1 row was updated:
+
+```
+Query OK, 1 row affected (0.01 sec)
+Rows matched: 1  Changed: 1  Warnings: 0
+```
+
+Now, if you again run the `SELECT id, username, about FROM users` query, you would see that the user with `id` of 2 now has an updated `about` column data:
+
+```
++----+----------+-------------------+
+| id | username | about             |
++----+----------+-------------------+
+|  2 | bobby    | Hello World :)    |
+|  3 | devdojo  | 404 bio not found |
+|  4 | tony     | 404 bio not found |
+|  5 | bobby    | 404 bio not found |
+|  6 | devdojo  | 404 bio not found |
+|  7 | tony     | 404 bio not found |
++----+----------+-------------------+
+```

package/example/assets/pages_data/en/content/010-delete.md

@@ -0,0 +1,28 @@
+# DELETE
+
+As the name suggests, the `DELETE` statement would remove data from your database.
+
+The syntax is as follows:
+
+```sql
+DELETE FROM users WHERE id=5;
+```
+
+The output should indicate that 1 row was affected:
+
+```
+Query OK, 1 row affected (0.01 sec)
+```
+
+> Important: Just like the `UPDATE` statement, if you don't specify a `WHERE` clause, all of the entries from the table will be affected, meaning that all of your users will be deleted. So, it is critical to always add a `WHERE` clause when executing a `DELETE` statement.
+
+```sql
+DELETE FROM users;
+```
+
+The output should indicate (where x is the number of tuples in the table):
+```
+Query OK, x row(s) affected (0.047 sec)
+```
+
+Similar to the Linux `rm` command, when you use the `DELETE` statement, the data would be gone permanently, and the only way to recover your data would be by restoring a backup.

package/example/assets/pages_data/en/content/011-join.md

@@ -0,0 +1,297 @@
+# JOIN
+
+The `JOIN` clause allows you to combine the data from 2 or more tables into one result set.
+
+As we will be selecting from multiple columns, we need to include the list of the columns we want to choose data from after the `FROM` clause is separated by a comma.
+
+In this chapter, we will go over the following `JOIN` types:
+
+* `CROSS` Join
+* `INNER` Join
+* `LEFT` Join
+* `RIGHT` Join
+
+Before we get started, let's create a new database and two tables that we are going to work with:
+
+* We are going to call the database `demo_joins`:
+
+```sql
+CREATE DATABASE demo_joins;
+```
+
+* Then, switch to the new database:
+
+```sql
+USE demo_joins;
+```
+
+* Then, the first table will be called `users`, and it will only have two columns: `id` and `username`:
+
+```sql
+CREATE TABLE users
+(
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    username VARCHAR(255) NOT NULL
+);
+```
+
+* Then, let's create a second table called `posts`, and to keep things simple, we will have three two columns: `id`, `user_id` and `title`:
+
+```sql
+CREATE TABLE posts
+(
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    user_id INT,
+    title VARCHAR(255) NOT NULL
+);
+```
+
+> The `user_id` column would be used to reference the user's ID that the post belongs to. It is going to be a one to many relations, e.g. one user could have many posts:
+
+![One to many relation](https://imgur.com/ipIjCaL.png)
+
+* Now, let's add some data into the two tables first by creating a few users:
+
+```sql
+INSERT INTO users
+  ( username )
+VALUES
+  ('bobby'),
+  ('devdojo'),
+  ('tony'),
+  ('greisi');
+```
+
+* And finally add some posts:
+
+```sql
+INSERT INTO posts
+  ( user_id, title )
+VALUES
+  ('1', 'Hello World!'),
+  ('2', 'Getting started with SQL'),
+  ('3', 'SQL is awesome'),
+  ('2', 'MySQL is up!'),
+  ('1', 'SQL - structured query language');
+```
+
+Now that we've got our tables and demo data ready, let's go ahead and learn how to use joins.
+
+## CROSS JOIN
+
+The `CROSS` join allows you to put the result of two tables next to each other without specifying any `WHERE` conditions. This makes the `CROSS` join the simplest one, but it is also not of much use in a real-life scenario.
+
+So if we were to select all of the users and all of the posts side by side, we would use the following query:
+
+```sql
+SELECT * FROM users CROSS JOIN posts;
+```
+
+The output will be all of your users and all of the posts side by side:
+
+```
++----+----------+----+--------+-----------------+
+| id | username | id |user_id | title           |
++----+----------+----+--------+-----------------+
+|  4 | greisi   |  1 |      1 | Hello World!    |
+|  3 | tony     |  1 |      1 | Hello World!    |
+|  2 | devdojo  |  1 |      1 | Hello World!    |
+|  1 | bobby    |  1 |      1 | Hello World!    |
+|  4 | greisi   |  2 |      2 | Getting started |
+|  3 | tony     |  2 |      2 | Getting started |
+|  2 | devdojo  |  2 |      2 | Getting started |
+|  1 | bobby    |  2 |      2 | Getting started |
+|  4 | greisi   |  3 |      3 | SQL is awesome  |
+|  3 | tony     |  3 |      3 | SQL is awesome  |
+|  2 | devdojo  |  3 |      3 | SQL is awesome  |
+|  1 | bobby    |  3 |      3 | SQL is awesome  |
+|  4 | greisi   |  4 |      2 | MySQL is up!    |
+|  3 | tony     |  4 |      2 | MySQL is up!    |
+|  2 | devdojo  |  4 |      2 | MySQL is up!    |
+|  1 | bobby    |  4 |      2 | MySQL is up!    |
+|  4 | greisi   |  5 |      1 | SQL             |
+|  3 | tony     |  5 |      1 | SQL             |
+|  2 | devdojo  |  5 |      1 | SQL             |
+|  1 | bobby    |  5 |      1 | SQL             |
++----+----------+----+--------+-----------------+
+```
+
+As mentioned above, you will highly unlikely run a `CROSS` join for two whole tables in a real-life scenario. If the tables have tens of thousands of rows, an unqualified CROSS JOIN can take minutes to complete.
+
+You would most likely use one of the following with a specific condition.
+
+In MySQL, CROSS JOIN and INNER JOIN are equivalent to JOIN.
+
+## INNER JOIN
+
+The `INNER` join is used to join two tables. However, unlike the `CROSS` join, by convention, it is based on a condition. By using an `INNER` join, you can match the first table to the second one.
+
+As we have a one-to-many relationship, a best practice would be to use a primary key for the posts `id` column and a foreign key for the `user_id`; that way, we can 'link' or relate the users table to the posts table. However, this is beyond the scope of this SQL basics eBook, though I might extend it in the future and add more chapters.
+
+As an example and to make things a bit clearer, let's say that you wanted to get all of your users and the posts associated with each user. The query that we would use will look like this:
+
+```sql
+SELECT *
+FROM users
+INNER JOIN posts
+ON users.id = posts.user_id;
+```
+
+Rundown of the query:
+
+* `SELECT * FROM users`: This is a standard select we've covered many times in the previous chapters.
+* `INNER JOIN posts`: Then, we specify the second table and which table we want to join the result set.
+* `ON users.id = posts.user_id`: Finally, we specify how we want the data in these two tables to be merged. The `user.id` is the `id` column of the `user` table, which is also the primary ID, and `posts.user_id` is the foreign key in the email address table referring to the ID column in the users table.
+
+The output will be the following, associating each user with their post based on the `user_id` column:
+
+```
++----+----------+----+---------+-----------------+
+| id | username | id | user_id | title           |
++----+----------+----+---------+-----------------+
+|  1 | bobby    |  1 |       1 | Hello World!    |
+|  2 | devdojo  |  2 |       2 | Getting started |
+|  3 | tony     |  3 |       3 | SQL is awesome  |
+|  2 | devdojo  |  4 |       2 | MySQL is up!    |
+|  1 | bobby    |  5 |       1 | SQL             |
++----+----------+----+---------+-----------------+
+```
+Note that the INNER JOIN could (in MySQL) equivalently be written merely as JOIN, but that can vary for other SQL dialects:
+
+```sql
+SELECT *
+FROM users
+JOIN posts
+ON users.id = posts.user_id;
+```
+
+The main things that you need to keep in mind here are the `INNER JOIN` and `ON` clauses.
+
+With the inner join, the `NULL` values are discarded. For example, if you have a user who does not have a post associated with it, the user with NULL posts will not be displayed when running the above `INNER` join query.
+
+To get the null values as well, you would need to use an outer join.
+
+### Types of INNER JOIN
+
+1.  **Theta Join ( θ )** :- Theta join combines rows from different tables provided they satisfy the theta condition.
+    The join condition is denoted by the symbol `θ`. \
+    Here the comparison operators `(≤, ≥, ˂, ˃, =, ̚ )` come into picture. \
+    **Notation** :- R<sub>1</sub> ⋈<sub>θ</sub> R<sub>2</sub>. \
+    \
+    For example, suppose we want to buy a mobile and a laptop, based on our budget we have thought of buying both such that mobile price should be less than that of laptop. \
+    \
+    `SELECT mobile.model, laptop.model
+    FROM mobile, laptop
+    WHERE mobile.price < laptop.price;`
+
+2.  **Equijoin** :- When Theta join uses only equality (=) comparison operator, it is said to be equijoin. \
+    For example, suppose we want to buy a mobile and a laptop, based on our budget we have thought of buying both of the same prices. \
+    \
+    `SELECT mobile.model, laptop.model
+    FROM mobile, laptop
+    WHERE mobile.price = laptop.price;`
+
+3.  **Natural Join ( ⋈ )** :- Natural join does not use any comparison operator. It does not concatenate the way a Cartesian product does. \
+    We can perform a Natural Join only if at least one standard column exists between two tables. In addition, the column must have the same name and domain. \
+    \
+    `SELECT * FROM mobile NATURAL JOIN laptop;`
+
+
+## LEFT JOIN
+
+Using the `LEFT OUTER` join, you would get all rows from the first table that you've specified, and if there are no associated records within the second table, you will get a `NULL` value.
+
+In our case, we have a user called `graisi`, which is not associated with a specific post. As you can see from the output from the previous query, the `graisi` user was not present there. To show that user, even though it does not have an associated post with it, you could use a `LEFT OUTER` join:
+
+```sql
+SELECT *
+FROM users
+LEFT JOIN posts
+ON users.id = posts.user_id;
+```
+
+The output will look like this:
+
+```
++----+----------+------+---------+-----------------+
+| id | username | id   | user_id | title           |
++----+----------+------+---------+-----------------+
+|  1 | bobby    |    1 |       1 | Hello World!    |
+|  2 | devdojo  |    2 |       2 | Getting started |
+|  3 | tony     |    3 |       3 | SQL is awesome  |
+|  2 | devdojo  |    4 |       2 | MySQL is up!    |
+|  1 | bobby    |    5 |       1 | SQL             |
+|  4 | greisi   | NULL |    NULL | NULL            |
++----+----------+------+---------+-----------------+
+```
+
+## RIGHT JOIN
+
+The `RIGHT OUTER` join is the exact opposite of the `LEFT OUTER` join. It will display all of the rows from the second table and give you a `NULL` value in case that it does not match with an entry from the first table.
+
+Let's create a post that does not have a matching user id:
+
+```sql
+INSERT INTO posts
+  ( user_id, title )
+VALUES
+  ('123', 'No user post!');
+```
+
+We specify `123` as the user ID, but we don't have such a user in our `users` table.
+
+Now, if you were to run the `LEFT` outer join, you would not see the post as it has a null value for the corresponding `users` table.
+
+But if you were to run a `RIGHT` outer join, you would see the post but not the `greisi` user as it does not have any posts:
+
+```sql
+SELECT *
+FROM users
+RIGHT JOIN posts
+ON users.id = posts.user_id;
+```
+
+Output:
+
+```
++------+----------+----+---------+-----------------+
+| id   | username | id | user_id | title           |
++------+----------+----+---------+-----------------+
+|    1 | bobby    |  1 |       1 | Hello World!    |
+|    2 | devdojo  |  2 |       2 | Getting started |
+|    3 | tony     |  3 |       3 | SQL is awesome  |
+|    2 | devdojo  |  4 |       2 | MySQL is up!    |
+|    1 | bobby    |  5 |       1 | SQL             |
+| NULL | NULL     |  6 |     123 | No user post!   |
++------+----------+----+---------+-----------------+
+```
+
+Joins can also be limited with WHERE conditions. For instance, in the preceding example, if we wanted to join the tables and then restrict to only username `bobby`.
+
+
+```sql
+SELECT *
+FROM users
+RIGHT JOIN posts
+ON users.id = posts.user_id
+WHERE username = 'bobby';
+```
+
+Output:
+
+```
++------+----------+----+---------+-----------------+
+| id   | username | id | user_id | title           |
++------+----------+----+---------+-----------------+
+|    1 | bobby    |  1 |       1 | Hello World!    |
+|    1 | bobby    |  5 |       1 | SQL             |
++------+----------+----+---------+-----------------+
+```
+
+## Conclusion
+
+Joins are fundamental to using SQL with data. The whole concept of joins might be very confusing initially but would make a lot of sense once you get used to it.
+
+The best way to wrap your head around it is to write some queries, play around with each type of `JOIN`, and see how the result set changes.
+
+For more information, you could take a look at the official documentation [here](https://dev.mysql.com/doc/refman/8.0/en/join.html).