360 lines
11 KiB
Markdown
360 lines
11 KiB
Markdown
|
# 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.
|