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

package/example/assets/pages_data/en/content/005-select.md

@@ -1,359 +0,0 @@
-# SELECT
-
-As we briefly covered in the previous chapter, the `SELECT` statement allows us to retrieve data from single or multiple tables on the database. In this chapter, we will be performing the query on a single table.
-
-It corresponds to the projection operation of Relational Algebra.
-
-You can use `SELECT` to get all of your users or a list of users that match a certain criteria.
-
-Before we dive into the `SELECT` statement let's quickly create a database:
-
-```sql
-CREATE DATABASE sql_demo;
-```
-
-Switch to that database:
-
-```sql
-USE sql_demo;
-```
-
-Create a new users table:
-
-```sql
-CREATE TABLE users
-(
-    id INT PRIMARY KEY AUTO_INCREMENT,
-    username VARCHAR(255) NOT NULL,
-    about TEXT,
-    email VARCHAR(255),
-    birthday DATE,
-    active BOOL
-);
-```
-
-Insert some data that we could work with:
-
-```sql
-INSERT INTO users
-  ( username, email, active )
-VALUES
-  ('bobby', 'b@devdojo.com', true),
-  ('devdojo', 'd@devdojo.com', false),
-  ('tony', 't@devdojo.com', true);
-```
-
-Output:
-
-```
-Query OK, 3 rows affected (0.00 sec)
-Records: 3  Duplicates: 0  Warnings: 0
-```
-
-We are going to learn more about the `INSERT` statement in the following chapters.
-
-## SELECT all columns
-
-Now that we've got some data in the `users` table, let's go ahead and retrieve all of the entries from that table:
-
-```sql
-SELECT * FROM users;
-```
-
-Rundown of the statement:
-
-* `SELECT`: First, we specify the action that we want to execute, in our case, we want to select or get some data from the database.
-* `*`: The star here indicates that we want to get all of the columns associated with the table that we are selecting from.
-* `FROM`: The from statement tells MySQL which table we want to select the data from. You need to keep in mind that you can select from multiple tables, but this is a bit more advanced, and we are going to cover this in the next few chapters.
-* `users`: This is the table name that we want to select the data from.
-
-This will return all of the entries in the `users` table along with all of the columns:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  1 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  2 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-|  3 | tony     | NULL  | NULL     |      1 | t@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-3 rows in set (0.00 sec)
-```
-
-As you can see, we get a list of the 3 users that we've just created, including all of the columns in that table. In some cases, the table might have a lot of columns, and you might not want to see all of them. For example, we have the `about` and `birthday` columns that are all `NULL` at the moment. So let's see how we could limit that and get only a list of specific columns.
-
-## Pattern matching
-SQL pattern matching let's you to search for patterns if you don't know the exact word or phrase you are looking for. To do this, we use so-called wildcard characters to match a pattern together with LIKE and ILIKE operators.
-
-Two of the most common wildcard characters are `_` and `%`.
-
-`_` matches any single character and `%` matches an arbitrary number of characters.
-
-Let's see an example how you would look for a `username` ending with `y`:
-
-```sql
-SELECT * FROM users WHERE username LIKE '%y';
-```
-
-Output:
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  1 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  3 | tony     | NULL  | NULL     |      1 | t@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-As you can see above, we used `%` to match any number of characters preceding the character `y`.
-
-If we know the exact number of characters we want to match, we can use `_`. Each `_` represents a single character.
-
-So, if we want to look up an username that has `e` as its second character, we would do something like this:
-
-```sql
-SELECT * FROM users WHERE username LIKE '_e%';
-```
-
-Output:
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-Please, keep in mind that `LIKE` operator is case sensitive, meaning it won't mach capital letters with lowercase letters and vice versa. If you wish to ignore capitalization, use `ILIKE` operator instead.
-
-
-## Formatting
-
-As we mentioned in the previous chapters, each SQL statement needs to end with a  semi-colon: `;`. Alternatively, rather than using a  semi-colon, you could use the `\G` characters which would format the output in a list rather than a table.
-
-The syntax is absolutely the same but you just change the `;` with `\G`:
-
-```sql
-SELECT * FROM users \G
-```
-
-The output will be formatted like this:
-
-```
-*************************** 1. row ***************************
-      id: 1
-username: bobby
-   about: NULL
-birthday: NULL
-  active: 1
-   email: b@devdojo.com
-*************************** 2. row ***************************
-      id: 2
-username: devdojo
-   about: NULL
-birthday: NULL
-  active: 0
-   email: d@devdojo.com
-...
-```
-
-This is very handy whenever your table consists of a large number of columns and they can't fit on the screen, which makes it very hard to read the result set.
-
-## SELECT specific columns only
-
-You could limit this to a specific set of columns. Let's say that you only needed the `username` and the `active` columns. In this case, you would change the `*` symbol with the columns that you want to select divided by a comma:
-
-```sql
-SELECT username,active FROM users;
-```
-
-Output:
-
-```
-+----------+--------+
-| username | active |
-+----------+--------+
-| bobby    |      1 |
-| devdojo  |      0 |
-| tony     |      1 |
-+----------+--------+
-```
-
-As you can see, we are getting back only the 2 columns that we've specified in the `SELECT` statement.
-
-> **NOTE:**  _SQL names are case insensitive. For example, username ≡ USERNAME ≡ userName._
-
-## SELECT with no FROM Clause
-
-In a SQL statement, a column can be a literal with no `FROM` clause.
-
-```sql
-SELECT 'Sunil' as username;
-```
-
-Output:
-
-```
-+----------+
-| username |
-+----------+
-| Sunil    |
-+----------+
-```
-
-## SELECT with Arithmetic Operations
-
-The select clause can contain arithmetic expressions involving the operation +, –, *, and /.
-
-```sql
-SELECT username, active*5 as new_active FROM users;
-```
-
-Output:
-
-```
-+----------+------------+
-| username | new_active |
-+----------+------------+
-| bobby    |          5 |
-| devdojo  |          0 |
-| tony     |          5 |
-+----------+------------+
-```
-
-## LIMIT
-
-The `LIMIT` clause is very handy in case that you want to limit the number of results that you get back. For example, at the moment, we have 3 users in our database, but let's say that you only wanted to get 1 entry back when you run the `SELECT` statement.
-
-This can be achieved by adding the `LIMIT` clause at the end of your statement, followed by the number of entries that you want to get. For example, let's say that we wanted to get only 1 entry back. We would run the following query:
-
-```sql
-SELECT * FROM users LIMIT 1;
-```
-
-Output:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-If you wanted to get 2 entries, you would change `LIMIT 2` and so on.
-
-## COUNT
-
-In case that you wanted to get only the number of entries in a specific column, you could use the `COUNT` function. This is a function that I personally use very often.
-
-The syntax is the following:
-
-```sql
-SELECT COUNT(*) FROM users;
-```
-
-Output:
-
-```
-+----------+
-| COUNT(*) |
-+----------+
-|        3 |
-+----------+
-```
-
-## MIN, MAX, AVG, and SUM
-
-Another useful set of functions similar to `COUNT` that would make your life easier are:
-
-* `MIN`: This would give you the smallest value of a specific column. For example, if you had an online shop and you wanted to get the lowest price, you would use the `MIN` function. In our case, if we wanted to get the lowest user ID, we would run the following:
-
-```sql
-SELECT MIN(id) FROM users;
-```
-
-This would return `1` as the lowest user ID that we have is 1.
-
-* `MAX`: Just like `MIN`, but it would return the highest value:
-
-```sql
-SELECT MAX(id) FROM users;
-```
-
-In our case, this would be `3` as we have only 3 users, and the highest value of the `id` column is 3.
-
-* `AVG`: As the name suggests, it would sum up all of the values of a specific column and return the average value. As we have 3 users with ids 1, 2, and 3, the average would be 6 divided by 3 users which is 2.
-
-```sql
-SELECT AVG(id) FROM users;
-```
-
-* `SUM`: This function takes all of the values from the specified column and sums them up:
-
-```sql
-SELECT SUM(id) FROM users;
-```
-
-## DISTINCT
-
-In some cases, you might have duplicate entries in a table, and in order to get only the unique values, you could use `DISTINCT`.
-
-To better demonstrate this, let's run the insert statement one more time so that we could duplicate the existing users and have 6 users in the users table:
-
-```sql
-INSERT INTO users
-  ( username, email, active )
-VALUES
-  ('bobby', 'b@devdojo.com', true),
-  ('devdojo', 'd@devdojo.com', false),
-  ('tony', 't@devdojo.com', true);
-```
-
-Now, if you run `SELECT COUNT(*) FROM users;` you would get `6` back.
-
-Let's also select all users and show only the `username` column:
-
-```sql
-SELECT username FROM users;
-```
-
-Output:
-
-```
-+----------+
-| username |
-+----------+
-| bobby    |
-| devdojo  |
-| tony     |
-| bobby    |
-| devdojo  |
-| tony     |
-+----------+
-```
-
-As you can see, each name is present multiple times in the list. We have `bobby`, `devdjo` and `tony` showing up twice.
-
-If we wanted to show only the unique `usernames`, we could add the `DISTINCT` keyword to our select statement:
-
-```sql
-SELECT DISTINCT username FROM users;
-```
-
-Output:
-
-```
-+----------+
-| username |
-+----------+
-| bobby    |
-| devdojo  |
-| tony     |
-+----------+
-```
-
-As you can see, the duplicate entries have been removed from the output.
-
-## Conclusion
-
-The `SELECT` statement is essential whenever working with SQL. In the next chapter, we are going to learn how to use the `WHERE` clause and take the `SELECT` statements to the next level.

package/example/assets/pages_data/en/content/006-where.md

@@ -1,225 +0,0 @@
-# WHERE
-
-The `WHERE` clause allows you to specify different conditions so that you could filter out the data and get a specific result set.
-
-You would add the `WHERE` clause after the `FROM` clause.
-
-The syntax would look like this:
-
-```sql
-SELECT column_name FROM table_name WHERE column=some_value;
-```
-
-## WHERE Clause example
-
-If we take the example `users` table from the last chapter, let's say that we wanted to get only the active users. The SQL statement would look like this:
-
-```sql
-SELECT DISTINCT username, email, activem FROM users WHERE active=true;
-```
-
-Output:
-
-```
-+----------+---------------+--------+
-| username | email         | active |
-+----------+---------------+--------+
-| bobby    | b@devdojo.com |      1 |
-| tony     | t@devdojo.com |      1 |
-+----------+---------------+--------+
-```
-
-As you can see, we are only getting `tony` and `bobby` back as their `active` column is `true` or `1`. If we wanted to get the inactive users, we would have to change the `WHERE` clause and set the `active` to `false`:
-
-```
-+----------+---------------+--------+
-| username | email         | active |
-+----------+---------------+--------+
-| devdojo  | d@devdojo.com |      0 |
-+----------+---------------+--------+
-```
-
-As another example, let's say that we wanted to select all users with the username `bobby`. The query, in this case, would be:
-
-```sql
-SELECT username, email, active FROM users WHERE username='bobby';
-```
-
-The output would look like this:
-
-```
-+----------+---------------+--------+
-| username | email         | active |
-+----------+---------------+--------+
-| bobby    | b@devdojo.com |      1 |
-| bobby    | b@devdojo.com |      1 |
-+----------+---------------+--------+
-```
-
-We are getting 2 entries back as we have 2 users in our database with the username `bobby`.
-
-## Operators
-
-In the example, we used the `=` operator, which checks if the result set matches the value that we are looking for.
-
-A list of popular operators are:
-
-* `!=` : Not equal operator
-* `>` : Greater than
-* `>=` : Greater than or equal operator
-* `<` : Less than operator
-* `<=` : Less than or equal operator
-
-For more information about other available operators, make sure to check the official documentation [here](https://dev.mysql.com/doc/refman/8.0/en/non-typed-operators.html).
-
-## AND keyword
-
-In some cases, you might want to specify multiple criteria. For example, you might want to get all users that are active, and the username matches a specific value. This could be achieved with the `AND` keyword.
-
-Syntax:
-
-```sql
-SELECT * FROM users WHERE username='bobby' AND active=true;
-```
-
-The result set would contain the data that matches both conditions. In our case, the output would be:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  5 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-If we were to change the `AND` statement to `active=false`, we would not get any results back as none of the entries in our database match that condition:
-
-```sql
-SELECT * FROM users WHERE username='bobby' AND active=false;
-```
-```
--- Output:
-Empty set (0.01 sec)
-```
-
-## OR keyword
-
-In some cases, you might want to specify multiple criteria. For example, you might want to get all users that are active, or their username matches a specific value. This could be achieved with the `OR` keyword.
-
-As with any other programming language, the main difference between `AND` and `OR` is that with `AND`, the result would only return the values that match the two conditions, and with `OR`, you would get a result that matches either of the conditions.
-
-For example, if we were to run the same query as above but change the `AND` to `OR`, we would get all users that have the username `bobby` and also all users that are not active:
-
-```sql
-SELECT * FROM users WHERE username='bobby' OR active=false;
-```
-
-Output:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  3 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-|  5 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  6 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-## LIKE operator
-
-Unlike the `=` operator, the `LIKE` operator allows you to do wildcard matching similar to the `*` symbol in Linux.
-
-For example, if you wanted to get all users that have the `y` letter in them, you would run the following:
-
-```sql
-SELECT * FROM users WHERE username LIKE '%y%';
-```
-
-Output
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  4 | tony     | NULL  | NULL     |      1 | t@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-As you can see, we are getting only `tony` and `bobby` but not `devdojo` as there is no `y` in `devdojo`.
-
-This is quite handy when you are building some search functionality for your application.
-
-# IN operator
-
-The `IN` operator allows you to provide a list expression and would return the results that match that list of values.
-
-For example, if you wanted to get all users that have the username `bobby` and `devdojo`, you could use the following:
-
-```sql
-SELECT * FROM users WHERE username IN ('bobby', 'devdojo');
-```
-
-Output:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  2 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  3 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-|  5 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  6 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-This allows you to simplify your `WHERE` expression so that you don't have to add numerous `OR` statements.
-
-## IS operator
-
-If you were to run `SELECT * FROM users WHERE about=NULL;` you would get an empty result set as the `=` operator can't be used to check for NULL values. Instead, you would need to use the `IS` operator instead.
-
-The `IS` operator is only used to check `NULL` values, and the syntax is the following:
-
-```sql
-SELECT * FROM users WHERE about IS NULL;
-```
-
-If you wanted to get the results where the value is not NULL, you just need to change `IS` to `IS NOT`:
-
-
-```sql
-SELECT * FROM users WHERE about IS NOT NULL;
-```
-
-## BETWEEN operator
-
-The `BETWEEN` operator allows to select value with a given range.The values can be numbers, text, or dates.
-BETWEEN operator is inclusive: begin and end values are included.
-
-For Example if you want to select those user which have id between 3 and 6.
-
-```sql
-SELECT * FROM users WHERE id BETWEEN 3 AND 6;
-```
-
-Output:
-
-```
-+----+----------+-------+----------+--------+---------------+
-| id | username | about | birthday | active | email         |
-+----+----------+-------+----------+--------+---------------+
-|  3 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-|  5 | bobby    | NULL  | NULL     |      1 | b@devdojo.com |
-|  6 | devdojo  | NULL  | NULL     |      0 | d@devdojo.com |
-+----+----------+-------+----------+--------+---------------+
-```
-
-## Conclusion
-
-In this chapter, you've learned how to use the `WHERE` clause with different operators to get different type of results based on the parameters that you provide.
-
-In the next chapter, we will learn how to order the result set.