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

package/example/assets/pages_data/en/content/002-install-mysql.md

@@ -0,0 +1,162 @@
+# MySQL
+
+Now that you know what a database, table, and column are, the next thing that you would need to do is install a database service where you would be running your SQL queries on.
+
+We will be using MySQL as it is free, open-source, and very widely used.
+
+## Installing MySQL
+
+Depending on your operating system, to install MySQL run the following commands.
+
+### Install MySQL on Ubuntu
+
+To install MySQL on a Linux or Ubuntu machine, run the following commands:
+
+* First update your `apt` repository:
+
+```
+sudo apt update -y
+```
+
+* Then install MySQL:
+
+```
+sudo apt install mysql-server mysql-client
+```
+
+We are installing two packages, one is the actual MySQL server, and the other is the MySQL client, which would allow us to connect to the MySQL server and run our queries.
+
+To check if MySQL is running, run the following command:
+
+```
+sudo systemctl status mysql.service
+```
+To secure your MySQL server, you could run the following command:
+
+```
+sudo mysql_secure_installation
+```
+
+Then follow the prompt and choose a secure password and save it in a secure place like a password manager.
+
+With that, you would have MySQL installed on your Ubuntu server. The above should also work just fine on Debian.
+
+### Install MySQL on Mac
+
+I would recommend installing MySQL using [Homebrew]():
+
+```
+brew install mysql
+```
+
+After that, start MySQL:
+
+```
+brew services start mysql
+```
+
+And finally, secure it:
+
+```
+mysql_secure_installation
+```
+
+In case that you ever need to stop the MySQL service, you could do so with the following command:
+
+```
+brew services stop mysql
+```
+
+### Install MySQL on Windows
+
+To install MySQL on Windows, I would recommend following the steps from the official documentation here:
+
+[https://dev.mysql.com/doc/refman/8.0/en/windows-installation.html](https://dev.mysql.com/doc/refman/8.0/en/windows-installation.html)
+
+## Accessing MySQL via CLI
+
+To access MySQL run the `mysql` command followed by your user:
+
+```
+mysql -u root -p
+```
+
+## Creating a database
+
+After that, switch to the `demo` database that we created in the previous chapter:
+
+```sql
+USE demo;
+```
+
+To exit the just type the following:
+
+```
+exit;
+```
+
+## Configuring `.my.cnf`
+
+By configuring the `~/.my.cnf` file in your user's home directory, MySQL would allow you to log in without prompting you for a password.
+
+To make that change, what you need to do is first create a `.my.cnf` file in your user's home directory:
+
+```
+touch ~/.my.cnf
+```
+
+After that, set secure permissions so that other regular users could not read the file:
+
+```
+chmod 600 ~/.my.cnf
+```
+
+Then using your favourite text editor, open the file:
+
+```
+nano ~/.my.cnf
+```
+
+And add the following configuration:
+
+```
+[client]
+user=YOUR_MYSQL_USERNAME
+password=YOUR_MYSQL_PASSWORD
+```
+
+Make sure to update your MySQL credentials accordingly, then save the file and exit.
+
+After that, if you run just `mysql`, you will be authenticated directly with the credentials that you've specified in the `~/.my.cnf` file without being prompted for a password.
+
+## The mysqladmin command
+
+As a quick test, you could check all of your open SQL connections by running the following command:
+
+```
+mysqladmin proc
+```
+
+The `mysqladmin` tool would also use the client details from the `~/.my.cnf` file, and it would list your current MySQL process list.
+
+Another cool thing that you could try doing is combining this with the `watch` command and kind of monitor your MySQL connections in almost real-time:
+
+```
+watch -n1 mysqladmin proc
+```
+
+To stop the `watch` command, just hit `CTRL+C`
+
+## GUI clients
+
+If you prefer using GUI clients, you could take a look a the following ones and install them locally on your laptop:
+
+* [MySQL Workbench](https://www.mysql.com/products/workbench/)
+* [Sequel Pro](https://www.sequelpro.com/)
+* [TablePlus](https://tableplus.com/)
+
+This will allow you to connect to your database via a graphical interface rather than the `mysql` command-line tool.
+
+If you want to have a production-ready MySQL database, I would recommend giving DigitalOcean a try:
+
+[Worry-free managed database hosting](https://www.digitalocean.com/products/managed-databases/)

package/example/assets/pages_data/en/content/003-creating-tables.md

@@ -0,0 +1,304 @@
+# Tables
+
+Before we get started with SQL, let's learn how to create tables and columns.
+
+As an example, we are going to create a `users` table with the following columns:
+
+* `id` - this is going to be the primary key of the table and would be the unique identifier of each user.
+* `username` - this column would hold the username of our users.
+* `name` - here, we will store the full name of users.
+* `status` - here, we will store the status of a user, which would indicate if a user is active or not.
+
+You need to specify the data type of each column.
+
+In our case it would be like this:
+
+* `id` - Integer
+* `username` - Varchar
+* `name` - Varchar
+* `status` - Number
+
+## Data types
+
+The most common data types that you would come across are:
+
+* `CHAR`(size): Fixed-length character string with a maximum length of 255 bytes.
+* `VARCHAR`(size):  Variable-length character string. Max size is specified in parenthesis.
+* `TEXT`(size): A string with a maximum length of 65,535 bytes.
+* `INTEGER`(size) or `INT`(size): A medium integer.
+* `BOOLEAN` or `BOOL`: Holds a true or false value.
+* `DATE`: Holds a date.
+
+Let's have the following users table as an example:
+
+* `id`: We would want to set the ID to `INT`.
+* `name`: The name should fit in a `VARCHAR` column.
+* `about`: As the about section could be longer, we could set the column data type to `TEXT`.
+* `birthday`: For the birthday column of the user, we could use `DATE`.
+
+For more information on all data types available, make sure to check out the official documentation [here](https://dev.mysql.com/doc/refman/8.0/en/data-types.html).
+
+## Creating a database
+
+As we briefly covered in the previous chapter, before you could create tables, you would need to create a database by running the following:
+
+* First access MySQL:
+
+```
+mysql -u root -p
+```
+
+* Then create a database called `demo_db`:
+
+```sql
+CREATE DATABASE demo_db;
+```
+
+> Note: the database name needs to be unique, if you already have a database named `demo_db` you would receive an error that the database already exists.
+
+You can consider this database as the container where we would create all of the tables in.
+
+Once you've created the database, you need to switch to that database:
+
+```sql
+USE demo_db;
+```
+
+You can think of this as accessing a directory in Linux with the `cd` command. With `USE`, we switch to a specific database.
+
+Alternatively, if you do not want to 'switch' to the specific database, you would need to specify the so-called fully qualified table name. For example, if you had a `users` table in the `demo_db`, and you wanted to select all of the entries from that table, you could use one of the following two approaches:
+
+* Switch to the `demo_db` first and then run a select statement:
+
+```sql
+USE demo_db;
+SELECT username FROM users;
+```
+
+* Alternatively, rather than using the `USE` command first, specify the database name followed by the table name separated with a  dot: `db_name.table_name`:
+
+```sql
+SELECT username FROM demo_db.users;
+```
+
+We are going to cover the `SELECT` statement more in-depth in the following chapters.
+
+## Creating tables
+
+In order to create a table, you need to use the `CREATE TABLE` statement followed by the columns that you want to have in that table and their data type.
+
+Let's say that we wanted to create a `users` table with the following columns:
+
+* `id`: An integer value
+* `username`: A varchar value
+* `about`: A text type
+* `birthday`: Date
+* `active`: True or false
+
+The query that we would need to run to create that table would be:
+
+```sql
+CREATE TABLE users
+(
+    id INT,
+    username VARCHAR(255),
+    about TEXT,
+    birthday DATE,
+    active BOOL
+);
+```
+
+> Note: You need to select a database first with the `USE` command as mentioned above. Otherwise you will get the following error: `ERROR 1046 (3D000): No database selected.
+
+To list the available tables, you could run the following command:
+
+```sql
+SHOW TABLES;
+```
+
+Output:
+
+```
++-------------------+
+| Tables_in_demo_db |
++-------------------+
+| users             |
++-------------------+
+```
+
+### Creating a new table from an existing table
+
+You can create a new table from an existing table by using the `CREATE TABLE AS` statement.
+
+Let's test that by creating a new table from the table `users` which we created earlier.
+
+```sql
+CREATE TABLE users2 AS
+(
+    SELECT * FROM users
+);
+
+```
+
+The output that you would get would be:
+```
+Query OK, 0 rows affected (0.07 sec)
+Records: 0  Duplicates: 0  Warnings: 0
+```
+
+>Note: When creating a table in this way, the new table will be populated with the records from the existing table (based on the SELECT Statement)
+
+## Rename tables
+
+You can rename a table by using `ALTER TABLE` statement.
+
+Let's change name of user2 table to user3
+```sql
+ALTER TABLE user2 RENAME TO user3
+```
+
+## Dropping tables
+
+You can drop or delete tables by using the `DROP TABLE` statement.
+
+Let's test that and drop the table that we've just created:
+
+```sql
+DROP TABLE users;
+```
+
+The output that you would get would be:
+
+```
+Query OK, 0 rows affected (0.03 sec)
+```
+
+And now, if you were to run the `SHOW TABLES;` query again, you would get the following output:
+
+```
+Empty set (0.00 sec)
+```
+
+## Allowing NULL values
+
+By default, each column in your table can hold NULL values. In case that you don't wanted to allow NULL values for some of the columns in a specific table, you need to specify this during the table creation or later on change the table to allow that.
+
+For example, let's say that we want the `username` column to be a required one, we would need to alter the table create statement and include `NOT NULL` right next to the `username` column like this:
+
+```sql
+CREATE TABLE users
+(
+    id INT,
+    username VARCHAR(255) NOT NULL,
+    about TEXT,
+    birthday DATE,
+    active BOOL
+);
+```
+
+That way, when you try to add a new user, MySQL will let you know that the `username` column is required.
+
+## Specifying a primary key
+
+The primary key column, which in our case is the `id` column, is a unique identifier for our users.
+
+We want the `id` column to be unique, and also, whenever we add new users, we want the ID of the user to autoincrement for each new user.
+
+This can be achieved with a primary key and `AUTO_INCREMENT`. The primary key column needs to be `NOT NULL` as well.
+
+If we were to alter the table creation statement, it would look like this:
+
+```sql
+CREATE TABLE users
+(
+    id INT PRIMARY KEY AUTO_INCREMENT,
+    username VARCHAR(255) NOT NULL,
+    about TEXT,
+    birthday DATE,
+    active BOOL
+);
+```
+
+## Updating tables
+
+In the above example, we created a new table and then dropped it as it was empty. However, in a real-life scenario, this would really be the case.
+
+So whenever you need to add or remove a new column from a specific table, you would need to use the `ALTER TABLE` statement.
+
+Let's say that we wanted to add an `email` column with type varchar to our `users` table.
+
+The syntax would be:
+
+```sql
+ALTER TABLE users ADD email VARCHAR(255);
+```
+
+After that, if you were to describe the table, you would see the new column:
+
+```sql
+DESCRIBE users;
+```
+
+Output:
+
+```
++----------+--------------+------+-----+---------+
+| Field    | Type         | Null | Key | Default |
++----------+--------------+------+-----+---------+
+| id       | int          | NO   | PRI | NULL    |
+| username | varchar(255) | NO   |     | NULL    |
+| about    | text         | YES  |     | NULL    |
+| birthday | date         | YES  |     | NULL    |
+| active   | tinyint(1)   | YES  |     | NULL    |
+| email    | varchar(255) | YES  |     | NULL    |
++----------+--------------+------+-----+---------+
+```
+
+If you wanted to drop a specific column, the syntax would be:
+
+```sql
+ALTER TABLE table_name DROP COLUMN column_name;
+```
+
+> Note: Keep in mind that this is a permanent change, and if you have any critical data in the specific column, it would be deleted instantly.
+
+You can use the `ALTER TABLE` statement to also change the data type of a specific column. For example, you could change the `about` column from `TEXT` to `LONGTEXT` type, which could hold longer strings.
+
+> Note: Important thing to keep in mind is that if a specific table already holds a particular type of data value like an integer, you can't alter it to varchar, for example. Only if the column does not contain any values, then you could make the change.
+
+
+## Truncate table
+
+The `TRUNCATE TABLE` command is used to **delete all of the data** from an existing table, but not the table itself.
+
+* Syntax of Truncate table:
+
+```sql
+TRUNCATE TABLE table_name;
+```
+
+* Example:
+
+Consider a Sellers table having the following records:
+
+```
++----+----------+-----+-----------+----------+
+| ID | NAME     |Items| CITY      | SALARY   |
++----+----------+-----+-----------+----------+
+|  1 | Shivam   |  34 | Ahmedabad |  2000.00 |
+|  2 | Ajay     |  22 | Delhi     |  4400.00 |
+|  3 | Kaushik  |  28 | Kota      |  2000.00 |
+|  4 | Chaitali |  25 | Mumbai    |  6600.00 |
+|  5 | Hardik   |  26 | Bhopal    |  8100.00 |
+|  6 | Maria    |  23 | MP        |  4200.00 |
+|  7 | Muffy    |  29 | Indore    |  9000.00 |
++----+----------+-----+-----------+----------+
+```
+
+Following is the example of a Truncate command:
+
+```sql
+TRUNCATE TABLE Sellers;
+```
+
+After that if you do a `COUNT(*)` on that table you would see that the table is completely empty.

package/example/assets/pages_data/en/content/004-basic-syntax.md

@@ -0,0 +1,145 @@
+# Basic Syntax
+
+In this chapter, we will go over the basic SQL syntax.
+
+SQL statements are basically the 'commands' that you run against a specific database. Through the SQL statements, you are telling MySQL what you want it to do, for example, if you wanted to get the `username` of all of your users stored in the `users` table, you would run the following SQL statement:
+
+```sql
+SELECT username FROM users;
+```
+
+Rundown of the statement:
+
+* `SELECT`: First, we specify the `SELECT` keyword, which indicates that we want to select some data from the database. Other popular keywords are: `INSERT`, `UPDATE` and `DELETE`.
+* `username`: Then we specify which column we want to select.
+* `FROM users`: After that, we specify the table that we want to select the data from using the `FROM` keyword.
+* The semicolon `;` is highly recommended to put at the end. Standard SQL syntax requires it, but some "Database Management Systems' (DBMS)" are tolerant about it, but it's not worth the risk.
+
+If you run the above statement, you will get no results as the new `users` table that we've just created is empty.
+
+> As a good practice, all SQL keywords should be with uppercase, however, it would work just fine if you use lower case as well.
+
+Let's go ahead and cover the basic operations next.
+
+## INSERT
+
+To add data to your database, you would use the `INSERT` statement.
+
+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 ('bobby', 'bobby@bobbyiliev.com', true);
+```
+
+Rundown of the insert statement:
+
+* `INSERT INTO`: first, we specify the `INSERT INTO` keyword, which tells MySQL that we want to insert data a 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. The order of attributes is the same as in `users (...)`.
+
+## SELECT
+
+Once we've inserted that user, let's go ahead and retrieve the information.
+
+To retrieve information from your database, you could use the `SELECT` statement:
+
+```sql
+SELECT * FROM users;
+```
+
+Output:
+
+```
++----+----------+-------+----------+--------+---------------+
+| id | username | about | birthday | active | email         |
++----+----------+-------+----------+--------+---------------+
+|  1 | bobby    | NULL  | NULL     |      1 | bobby@b...com |
++----+----------+-------+----------+--------+---------------+
+```
+
+We specify `*` right after the `SELECT` keyword, this means that we want to get all of the columns from the `users` table.
+
+If we wanted to the only the `username` and the `email` columns instead, we would change the statement to:
+
+```sql
+SELECT username, email FROM users;
+```
+
+This will return all of the users, but as of the time being we have only 1:
+
+```
++----------+----------------------+
+| username | email                |
++----------+----------------------+
+| bobby    | bobby@bobbyiliev.com |
++----------+----------------------+
+```
+
+## UPDATE
+
+In order to modify data in your database, you could use the `UPDATE` statement.
+
+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.
+* `SET 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.
+
+> NOTE: If we 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`. You need to be careful when you use the `UPDATE` statement without a `WHERE` clause, as every single row will be updated.
+
+We are going to cover `WHERE` more in-depth in the next few chapters.
+
+## 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=1;
+```
+
+Similar to 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.
+
+## Comments
+
+In case that you are writing a larger SQL script, it might be helpful to add some comments so that later on, when you come back to the script, you would know what each line does.
+
+As with all programming languages, you can add comments in SQL as well.
+
+There are two types of comments:
+
+* Inline comments:
+
+To do so, you just need to add `--` before the text that you want to comment out:
+
+```sql
+SELECT * FROM users; -- Get all users
+```
+
+* Multiple-line comments:
+
+Similar to some other programming languages in order to comment multiple lines, you could wrap the text in `/*` `*/` as follows:
+
+```sql
+/*
+Get all of the users
+from your database
+*/
+SELECT * FROM users;
+```
+
+You could write that in a `.sql` file and then run it later on, or execute the few lines directly.
+
+## Conclusion
+
+Those were some of the most common basic SQL statements.
+
+In the next chapters, we are going to go over each of the above statements more in-depth.