sql select 语句

1. 查询单列

查询是数据库中最常用的功能。在 SQL 数据库中使用 SELECT 来实现选取数据的查询数据。结果存储在一个临时结果表中，这个表称为结果集。结果集实际上也是一种包含行与列的表，只不过是未持久化的，即临时表。未持久化 表示存储的数据不是永久的。

在使用 SELECT 语句检索表数据时，至少需要给出两条信息，要检索的列名 column_name 和被检索内容的表名 table_name。

查询单列数据
SELECT `column_name` FROM `table_name`;
或
SELECT column_name FROM table_name;
注意：列名 column_name 和表名 table_name 左右加的是什么，其实这是反引号（`），其实这不是必要的，只是我们在命名字段的时候，字段名可能会与 SQL 关键字冲突，这时候使用反引号将列名和表名包含一下，可以避免关键字冲突。

这里有一组数据，这是一个课程表，下面通过 SELECT COLUMN 查询所有课程名称，例如下面这样：

| id |           name            | student_count | created_at  | teacher_id |
| :- | :------------------------ | :------------ | :---------- | :--------- |
| 1  | 'Advanced Algorithms'     | 880           | '2020-6-1'  | 4          |
| 2  | 'System Design'           | 1350          | '2020-7-18' | 3          |
| 3  | 'Django'                  | 780           | '2020-2-29' | 3          |
| 4  | 'Web'                     | 340           | '2020-4-22' | 4          |
| 5  | 'Big Data'                | 700           | '2020-9-11' | 1          |
| 6  | 'Artificial Intelligence' | 1660          | '2018-5-13' | 3          |
| 7  | 'Java P6+'                | 780           | '2019-1-19' | 3          |
| 8  | 'Data Analysis'           | 500           | '2019-7-12' | 1          |
| 10 | 'Object Oriented Design'  | 300           | '2020-8-8'  | 4          |
| 12 | 'Dynamic Programming'     | 2000          | '2018-8-18' | 1          |

SELECT `name` FROM `courses`;

得到下面的输出

|           name            |
| :------------------------ |
| 'Advanced Algorithms'     |
| 'System Design'           |
| 'Django'                  |
| 'Web'                     |
| 'Big Data'                |
| 'Artificial Intelligence' |
| 'Java P6+'                |
| 'Data Analysis'           |
| 'Object Oriented Design'  |
| 'Dynamic Programming'     |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2. 查询多列

当我们想要从一个表中查询多个列时，使用的 SELECT 语句与查询一个列时使用的语句相似，但是需要在 SELECT 关键字后给出多个列名，并且列名之间必须以逗号分隔。

查询多列数据
SELECT `column_name1`, `column_name2` FROM `table_name`;
只需要在 SELECT 后指定需要查询的多个列名，各个列名使用逗号分隔。

这还是这个课程表，下面通过 SELECT COLUMN COLUMN 选取课程名称 name 和课程开课日期 created_at 的列，例如下面这样：

| id |           name            | student_count | created_at  | teacher_id |
| :- | :------------------------ | :------------ | :---------- | :--------- |
| 1  | 'Advanced Algorithms'     | 880           | '2020-6-1'  | 4          |
| 2  | 'System Design'           | 1350          | '2020-7-18' | 3          |
| 3  | 'Django'                  | 780           | '2020-2-29' | 3          |
| 4  | 'Web'                     | 340           | '2020-4-22' | 4          |
| 5  | 'Big Data'                | 700           | '2020-9-11' | 1          |
| 6  | 'Artificial Intelligence' | 1660          | '2018-5-13' | 3          |
| 7  | 'Java P6+'                | 780           | '2019-1-19' | 3          |
| 8  | 'Data Analysis'           | 500           | '2019-7-12' | 1          |
| 10 | 'Object Oriented Design'  | 300           | '2020-8-8'  | 4          |
| 12 | 'Dynamic Programming'     | 2000          | '2018-8-18' | 1          |

SELECT `name`, `created_at` FROM `courses`;

得到以下的输出

|           name            |  created_at  |
| :------------------------ | :----------- |
| 'Advanced Algorithms'     | '2020-06-01' |
| 'System Design'           | '2020-07-18' |
| 'Django'                  | '2020-02-29' |
| 'Web'                     | '2020-04-22' |
| 'Big Data'                | '2020-09-11' |
| 'Artificial Intelligence' | '2018-05-13' |
| 'Java P6+'                | '2019-01-19' |
| 'Data Analysis'           | '2019-07-12' |
| 'Object Oriented Design'  | '2020-08-08' |
| 'Dynamic Programming'     | '2018-08-18' |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3. 查询所有列

SELECT 语句可以直接检索表中所有信息，即检索所有的列。这可以通过在列名的位置使用星号（*）通配符来实现，输出的列的顺序一般是列在表定义中出现的物理顺序。

查询所有列数据
SELECT * FROM `table_name`;
注意：这里的星号是一个通配符，表示选择所有的数据列。

实际上通过这样的语法查询数据之后就是将整个数据表查询出来，因为在数据库中数据是按列进行归类存储的，选择所有列即选择了数据表中的所有数据。

4. 查询不同行

我们可以发现 SELECT 语句会返回所有匹配的行，有时候会遇到数据相同的情况。如果我们只想知道有哪些不同的值，即希望查询的值都是唯一不重复的，我们该怎么办呢？这时候我们就需要用到 DISTINCT 关键字。注意 DISTINCT 关键字必须位于列名之前。

查询不同行数据
SELECT DISTINCT `column_name` FROM `table_name`
DISTINCT 表示查询不同的唯一的数据行，比如需要搜索的列表中存在两个相同的人名，那么在查询时只会返回这两个中的一个。

| id |           name            | student_count | created_at  | teacher_id |
| :- | :------------------------ | :------------ | :---------- | :--------- |
| 1  | 'Advanced Algorithms'     | 880           | '2020-6-1'  | 4          |
| 2  | 'System Design'           | 1350          | '2020-7-18' | 3          |
| 3  | 'Django'                  | 780           | '2020-2-29' | 3          |
| 4  | 'Web'                     | 340           | '2020-4-22' | 4          |
| 5  | 'Big Data'                | 700           | '2020-9-11' | 1          |
| 6  | 'Artificial Intelligence' | 1660          | '2018-5-13' | 3          |

SELECT DISTINCT `teacher_id` FROM `courses`;

得到以下输出

| teacher_id |
| :--------- |
| 4          |
| 3          |
| 1          |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5. 数据行筛选过滤

在大多数的情况下我们需要对数据单元进行精准的查询，这时候就需要使用各种 条件 来筛选出合理的数据。这时可以使用 WHERE 子句来帮助筛选数据。SELECT WHERE 语句是筛选查询很重要的操作，WHERE 关键字后面加上条件可以过滤掉不需要的信息。比如使用 WHERE 可以选择需要的数据行。

SELECT `column_name1`, `column_name2` … `column_namen` FROM `table_name` WHERE `column_name` operator `value`;

column_name 对应指定列的名称，或者是多列，用逗号（,）分隔
table_name 对应查询表的名称
operator 为操作符，常用的有 等于 = 小于 < ，大于 > ，不等于<> 或 !=

从课程表 courses 中选取课程名为 ‘System Design’ 的课程，例如下面这样：

| id |           name            | student_count | created_at  | teacher_id |
| :- | :------------------------ | :------------ | :---------- | :--------- |
| 1  | 'Advanced Algorithms'     | 880           | '2020-6-1'  | 4          |
| 2  | 'System Design'           | 1350          | '2020-7-18' | 3          |
| 3  | 'Django'                  | 780           | '2020-2-29' | 3          |
| 4  | 'Web'                     | 340           | '2020-4-22' | 4          |
| 5  | 'Big Data'                | 700           | '2020-9-11' | 1          |
| 6  | 'Artificial Intelligence' | 1660          | '2018-5-13' | 3          |
| 7  | 'Java P6+'                | 780           | '2019-1-19' | 3          |
| 8  | 'Data Analysis'           | 500           | '2019-7-12' | 1          |
| 10 | 'Object Oriented Design'  | 300           | '2020-8-8'  | 4          |
| 12 | 'Dynamic Programming'     | 2000          | '2018-8-18' | 1          |

SELECT * FROM `courses` WHERE `name` = 'System Design';

得到以下输出

| id |      name       | student_count |  created_at  | teacher_id |
| :- | :-------------- | :------------ | :----------- | :--------- |
| 2  | 'System Design' | 1350          | '2020-07-18' | 3          |

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21