【MySQL | 四、表的基本查询（增删查改）】

表的增删查改
- Create(创建)
- - 表数据的插入
  - 替换
- Retrieve(读取)
- - 1. 全列查询
  - 2. 指定列查询
  - 3. 表达式查询
  - 4.为查询结果指定别名
  - 5.去重查询
- WHERE 条件
- - 查询排序
  - 筛选分页查询
- Update(更新)
- Delete(删除)
- - 删除整张表数据
- 插入查询结果
- 聚合函数
- - group by
  - - having和where的区别
    - - 1. 作用范围不同
      - 2. 执行顺序不同
- 查询语句执行顺序分析
- - 1. **`SELECT` 查询语句**
  - 2. **`INSERT` 插入语句**
  - 3. **`UPDATE` 更新语句**
  - 4. **`DELETE` 删除语句**

表的增删查改

CRUD : Create(创建), Retrieve(读取)，Update(更新)，Delete（删除）

用一下表结构举例：

mysql> desc exam_result;
+---------+------------------+------+-----+---------+----------------+
| Field   | Type             | Null | Key | Default | Extra          |
+---------+------------------+------+-----+---------+----------------+
| id      | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
| name    | varchar(20)      | NO   |     | NULL    |                |
| chinese | float            | YES  |     | 0       |                |
| math    | float            | YES  |     | 0       |                |
| english | float            | YES  |     | 0       |                |
+---------+------------------+------+-----+---------+----------------+

Create(创建)

表数据的插入

语法：

mysql> INSERT [INTO] 表名 -> (字段1, 字段2, ..., 字段n) -> VALUES (字段1的值, 字段2的值, ..., 字段n的值);

解释：

INTO可写，可不写。
VALUES前面为要插入数据的字段名，字段n为最后一个字段，除非字段会自增或有默认值否则表结构中的字段名都要写。
VALUES后为对应字段插入的值。
自定义数据全插时VALUES前的字段名可省略。
多行同时插入如示例

4中插入方式示例：

#自定义数据全列插的第一种方式
mysql> INSERT INTO exam_result -> (id, name, chinese, math, english) -> VALUES (1, '唐三藏', 67, 98, 56);#部分数据自定义插入：
mysql> insert into exam_result (name) values ('张三');#自定义数据全列插的第二种方式
mysql> INSERT INTO exam_result -> VALUES (3, '孙猴子', 80, 80, 20);#多行数据插入示例
mysql> INSERT INTO exam_result (name, chinese, math, english) VALUES-> ('猪悟能', 88, 98, 90),-> ('懒洋洋', 87, 78, 77),-> ('曹操', 88, 78, 67),-> ('曹孟德', 82, 84, 67),-> ('刘玄德', 55, 85, 45),-> ('孙权', 70, 73, 78),-> ('宋公明', 75, 65, 30);#总数据如下
mysql> select * from exam_result;
+----+-----------+---------+------+---------+
| id | name      | chinese | math | english |
+----+-----------+---------+------+---------+
|  1 | 唐三藏     |      67 |   98 |      56 |
|  2 | 张三       |       0 |    0 |       0 |
|  3 | 孙猴子     |      80 |   80 |      20 |
|  4 | 猪悟能     |      88 |   98 |      90 |
|  5 | 懒洋洋     |      87 |   78 |      77 |
|  6 | 曹操       |      88 |   78 |      67 |
|  7 | 曹孟德     |      82 |   84 |      67 |
|  8 | 刘玄德     |      55 |   85 |      45 |
|  9 | 孙权       |      70 |   73 |      78 |
| 10 | 宋公明     |      75 |   65 |      30 |
+----+-----------+---------+------+---------+
10 rows in set (0.00 sec)

由于主键或者唯一键对应的值已经存在而导致插入失败可通过一下语法进行更新式插入。

语法：

mysql> INSERT [INTO] 表名 -> (字段1, 字段2, ..., 字段n) -> VALUES (字段1的值, 字段2的值, ..., 字段n的值)-> ON DUPLICATE KEY UPDATE (字段1 = 字段1的值-> ，...)-- 0 row affected: 表中有冲突数据，但冲突数据的值和update 的值相等
-- 1 row affected: 表中没有冲突数据，数据被插入
-- 2 row affected: 表中有冲突数据，并且数据已经被更新

通过 MySQL 函数获取受到影响的数据行数
SELECT ROW_COUNT();

替换

主键或者唯一键没有冲突，则直接插入；
主键或者唯一键如果冲突，则删除后再插入
语法：
REPLACE INTO students (sn, name) VALUES (20001, '曹阿瞒');
Query OK, 2 rows affected (0.00 sec)
1 row affected: 表中没有冲突数据，数据被插入
2 row affected: 表中有冲突数据，删除后重新插入

Retrieve(读取)

1. 全列查询

SELECT * FROM [表名];
SELECT * FROM exam_result;

2. 指定列查询

SELECT * [字段名1],[字段名2],[...] FROM [表名];
SELECT id, name, english FROM exam_result;

3. 表达式查询

#对应的字段列为 数值时可进行表达式查询
SELECT 字段1, 字段2, 字段3 + 字段4 + 字段5 
FROM exam_result;SELECT id, name, chinese + math + english 
FROM exam_result;

4.为查询结果指定别名

字段名后跟as 或单空格跟别名均可

SELECT [字段1] AS [字段1别名] [...] FROM 表名;
SELECT id, name as 名字, chinese + math + english 总分 FROM exam_result;
+----+-----------+--------+
| id | 名字       | 总分   |
+----+-----------+--------+
| 1  | 唐三藏     | 221    |
+----+-----------+--------+

5.去重查询

SELECT DISTINCT [字段] FROM [表名];
SELECT DISTINCT math FROM exam_result;

WHERE 条件

select [字段1],[字段2] from [表名] where [筛选条件];
select name,mtch for exam_rasult where math>60;

运算符	说明
>, >=, <, <=	大于，大于等于，小于，小于等于
=	等于，NULL 不安全，例如 NULL = NULL 的结果是 NULL
<=>	等于，NULL 安全，例如 NULL <=> NULL 的结果是 TRUE(1)
!=, <>	不等于
BETWEEN a0 AND a1	范围匹配，[a0, a1]，如果 a0 <= value <= a1，返回 TRUE(1)
IN (option, …)	如果是 option 中的任意一个，返回 TRUE(1)
IS NULL	是 NULL
IS NOT NULL	不是 NULL
LIKE	模糊匹配。% 表示任意多个（包括 0 个）任意字符；_ 表示任意一个字符

查询排序

ASC 为升序（从小到大）
DESC 为降序（从大到小）
默认为 ASC

SELECT name, math FROM exam_result ORDER BY math desc;

注意：没有 ORDER BY 子句的查询，返回的顺序是未定义的，永远不要依赖这个顺序

筛选分页查询

-- 起始下标为 0
-- 从 s 开始，筛选 n 条结果
SELECT ... FROM table_name [WHERE ...] [ORDER BY ...] LIMIT s, n
-- 从 0 开始，筛选 n 条结果
SELECT ... FROM table_name [WHERE ...] [ORDER BY ...] LIMIT n;
;
-- 从 s 开始，筛选 n 条结果，比第二种用法更明确，建议使用
SELECT ... FROM table_name [WHERE ...] [ORDER BY ...] LIMIT n OFFSET s;

建议：对未知表进行查询时，最好加一条 LIMIT 1，避免因为表中数据过大，查询全表数据导致数据库卡死

Update(更新)

UPDATE 表名 SET 表达式 WHERE name = '孙悟空';
UPDATE exam_result SET math = 80 WHERE name = '孙悟空';

Delete(删除)

DELETE FROM 表名 WHERE 筛选条件;
DELETE FROM exam_result WHERE name = '孙悟空';

删除整张表数据

方式一：会重置 AUTO_INCREMENT 项

DELETE FROM 表名;
DELETE FROM for_delete;

方式二：

TRUNCATE [TABLE] 表名;

注意：这个操作慎用

只能对整表操作，不能像 DELETE 一样针对部分数据操作；
实际上 MySQL 不对数据操作，所以比 DELETE 更快，但是TRUNCATE在删除数据的时候，并不经过真正的事
物，所以无法回滚
会重置 AUTO_INCREMENT 项

插入查询结果

将查询结果直接插入到目标表。

INSERT INTO [目标表] (字段1, 字段2, ..., 字段n)
SELECT column1, column2, ..., columnN
FROM source_table
WHERE conditions;

SELECT column1, column2, …, columnN 指定查询的字段，这些字段的顺序和数量必须与 INSERT INTO 中的目标字段一致。
WHERE conditions 是可选的，用于过滤查询结果。

聚合函数

函数	说明
COUNT([DISTINCT] expr)	返回查询到的数据的数量
SUM([DISTINCT] expr)	返回查询到的数据的总和，不是数字没有意义
AVG([DISTINCT] expr)	返回查询到的数据的平均值，不是数字没有意义
MAX([DISTINCT] expr)	返回查询到的数据的最大值，不是数字没有意义
MIN([DISTINCT] expr)	返回查询到的数据的最小值，不是数字没有意义

group by

在select中使用group by 子句可以对指定列进行分组查询

select column1, column2, .. from table group by column;

having和group by配合使用，对group by结果进行过滤

select avg(sal) as myavg from EMP group by deptno having myavg<2000;

having经常和group by搭配使用，作用是对分组进行筛选，作用有些像where。

having和where的区别

1. 作用范围不同

WHERE 子句：

作用于行级别，用于在数据被分组之前进行过滤。
只能对表中的列或表达式进行过滤，不能直接对聚合函数进行过滤。
过滤条件基于单行数据，通常用于筛选满足条件的记录。

HAVING 子句：

作用于分组级别，用于在数据分组后对分组结果进行过滤。
可以对聚合函数（如 SUM、COUNT、AVG 等）进行过滤。
过滤条件基于分组后的结果，通常用于筛选满足条件的分组。

2. 执行顺序不同

在 SQL 查询的执行过程中，WHERE 子句先于 HAVING 子句执行：

首先，WHERE 子句对表中的数据进行筛选，过滤掉不符合条件的行。
然后，对筛选后的结果进行分组（GROUP BY）。
最后，HAVING 子句对分组后的结果进行过滤。

查询语句执行顺序分析

在数据库查询中，除了常见的 SELECT 查询语句外，还有其他类型的SQL语句，它们在执行时也有各自的逻辑顺序。以下是一些常见的SQL语句类型及其执行顺序分析：

1. `SELECT` 查询语句

这是最常见的一种查询语句，其执行顺序通常如下：

FROM：确定查询涉及的表或视图。
WHERE：对表中的数据进行过滤。
GROUP BY：对过滤后的数据进行分组。
HAVING：对分组后的数据进行过滤。
SELECT：选择需要的列。
ORDER BY：对最终结果进行排序。
LIMIT/OFFSET（如果存在）：限制返回的行数。

2. `INSERT` 插入语句

INSERT 语句用于向表中插入数据。其执行顺序如下：

目标表（INTO）：确定要插入数据的表。
数据来源：
- 如果是 INSERT INTO table VALUES (...)，直接提供插入的值。
- 如果是 INSERT INTO table SELECT ...，则先执行 SELECT 查询，获取数据。
数据校验：检查插入的数据是否符合表的约束（如主键、外键、唯一性等）。
插入数据：将数据写入表中。

3. `UPDATE` 更新语句

UPDATE 语句用于更新表中的数据，其执行顺序如下：

目标表：确定要更新的表。
WHERE：确定哪些行需要更新（如果没有 WHERE，则更新所有行）。
SET：指定需要更新的列和值。
数据校验：检查更新后的数据是否符合表的约束。
执行更新：将更新后的数据写入表中。

4. `DELETE` 删除语句

DELETE 语句用于删除表中的数据，其执行顺序如下：

目标表：确定要删除数据的表。
WHERE：确定哪些行需要删除（如果没有 WHERE，则删除所有行）。
执行删除：从表中移除指定的行。
触发器处理：如果表有触发器，执行相关触发器逻辑。