【MySQL】6.MySQL基本查询（1）

文章目录

[6. 表的增删改查](#6. 表的增删改查)
- [6.1 Create(创建)](#6.1 Create(创建))
- - [6.1.1 单行数据 + 全列插入](#6.1.1 单行数据 + 全列插入)
  - [6.1.2 多行数据 + 指定列插入](#6.1.2 多行数据 + 指定列插入)
  - [6.1.3 插入否则更新](#6.1.3 插入否则更新)
  - [6.1.4 替换-replace](#6.1.4 替换-replace)
- [6.2 Retrieve(读取/筛选)](#6.2 Retrieve(读取/筛选))
- - [DISTINCT]
  - [{* | {column [, column] ...}](#{* | {column [, column] ...})
  - [[FROM table_name]](#[FROM table_name])
  - [[WHERE ...]](#[WHERE ...])
  - [[ORDER BY column [ASC | DESC], ...]](#[ORDER BY column [ASC | DESC], ...])
  - [[LIMIT ...]](#[LIMIT ...])
  - [6.2.1 SELECT 列](#6.2.1 SELECT 列)
  - - [6.2.1.1 全列查询](#6.2.1.1 全列查询)
    - [6.2.1.2 指定列查询](#6.2.1.2 指定列查询)
    - [6.2.1.3 查询字段为表达式](#6.2.1.3 查询字段为表达式)
    - [6.2.1.4 为查询结果指定别名](#6.2.1.4 为查询结果指定别名)
    - [6.2.1.5 结果去重-distinct](#6.2.1.5 结果去重-distinct)

6. 表的增删改查

CRUD :

Create(创建)

Retrieve(读取)

Update(更新)

Delete(删除)

6.1 Create(创建)

语法：

mysql 复制代码

INSERT [INTO] table_name # INSERT [INTO]: 关键字，用于指示这是一个插入操作。"INTO"是可选的，但通常会使用。
# table_name: 要插入数据的表名。
 [(column [, column] ...)] #[(column [, column] ...)]: 可选部分，指定要插入数据的列名。如果不指定，则默认为表的所有列按顺序。
 VALUES (value_list) [, (value_list)] ... # VALUES: 关键字，表示后面跟着的是要插入的数据值。
 
value_list: value, [, value] ... # value_list: 代表一组要插入的值，多个值用逗号分隔，整组值用括号包围。
# [, (value_list)] ...: 表示可以同时插入多行数据，每组数据用逗号分隔。

案例：

mysql 复制代码

# 创建一张学生表
mysql> CREATE TABLE students (
    -> id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    -> sn INT NOT NULL UNIQUE COMMENT '学号',
    -> name VARCHAR(20) NOT NULL,
    -> qq VARCHAR(20)
    -> );
Query OK, 0 rows affected (0.03 sec)

6.1.1 单行数据 + 全列插入

mysql 复制代码

# 插入两条记录，value_list 数量必须和定义表的列的数量及顺序一致
# 注意，这里在插入的时候，也可以不用指定id(当然，那时候就需要明确插入数据到那些列了)，那么mysql会使用默认的值进行自增。
mysql> INSERT INTO students VALUES (100, 10000, '唐三藏', NULL);
Query OK, 1 row affected (0.01 sec)

mysql> INSERT INTO students VALUES (101, 10001, '孙悟空', '11111');
Query OK, 1 row affected (0.01 sec)

# 查看插入结果
mysql> SELECT * FROM students;
+-----+-------+-----------+-------+
| id  | sn    | name      | qq    |
+-----+-------+-----------+-------+
| 100 | 10000 | 唐三藏    | NULL  |
| 101 | 10001 | 孙悟空    | 11111 |
+-----+-------+-----------+-------+
2 rows in set (0.00 sec)

6.1.2 多行数据 + 指定列插入

mysql 复制代码

# 插入两条记录，value_list 数量必须和指定列数量及顺序一致
mysql> INSERT INTO students (id, sn, name) VALUES 
    -> (102, 20001, '曹孟德'), 
    -> (103, 20002, '孙仲谋');
Query OK, 2 rows affected (0.01 sec)
Records: 2  Duplicates: 0  Warnings: 0

-- 查看插入结果
mysql> SELECT * FROM students;
+-----+-------+-----------+-------+
| id  | sn    | name      | qq    |
+-----+-------+-----------+-------+
| 100 | 10000 | 唐三藏    | NULL  |
| 101 | 10001 | 孙悟空    | 11111 |
| 102 | 20001 | 曹孟德    | NULL  |
| 103 | 20002 | 孙仲谋    | NULL  |
+-----+-------+-----------+-------+
4 rows in set (0.00 sec)

6.1.3 插入否则更新

由于主键或者唯一键对应的值已经存在而导致插入失败

mysql 复制代码

# 主键冲突
mysql> INSERT INTO students (id, sn, name) VALUES (100, 10010, '唐大师');
ERROR 1062 (23000): Duplicate entry '100' for key 'students.PRIMARY'
# 唯一键冲突
mysql> INSERT INTO students (sn, name) VALUES (20001, '曹阿瞒');
ERROR 1062 (23000): Duplicate entry '20001' for key 'students.sn'

可以选择性的进行同步更新操作语法：

mysql 复制代码

INSERT ... ON DUPLICATE KEY UPDATE 
 column = value [, column = value] ... 
# INSERT : 指定要插入的表名。
# ON DUPLICATE KEY UPDATE: 关键部分，指示MySQL当插入导致唯一键冲突时应执行更新操作。
# column = value [, column = value] ...: 指定发生冲突时应更新哪些列及其新值。可以更新一个或多个列，用逗号分隔。

# 例子
# 假设我们有一个产品表products，包含产品ID（主键）、名称、价格和库存数量：
CREATE TABLE products (
    product_id INT PRIMARY KEY,
    product_name VARCHAR(100),
    price DECIMAL(10,2),
    stock INT
);
# 当我们要添加新产品或更新现有产品的库存时：
INSERT INTO products (product_id, product_name, price, stock)
VALUES (101, 'iPhone 14', 899.99, 50)
ON DUPLICATE KEY UPDATE # "尝试插入这行数据。如果因为主键或唯一键重复而失败，就转而执行更新操作。"，如果上面插入的数据不存在就插入，如果受到唯一性约束无法插入就执行下面的语句，更新数据
    product_name = VALUES(product_name),
    price = VALUES(price),
    stock = stock + VALUES(stock);
-- 这条语句的作用：

-- 如果产品ID 101不存在，则插入新记录
-- 如果产品ID 101已存在，则：
-- 		更新产品名称和价格为新值
-- 		将当前库存量增加50（累加库存）

mysql 复制代码

mysql> INSERT INTO students (id, sn, name) VALUES (100, 10010, '唐大师')
    -> ON DUPLICATE KEY UPDATE sn = 10010, name = '唐大师';
Query OK, 2 rows affected (0.01 sec)
-- 0 row affected: 表中有冲突数据，但冲突数据的值和 update 的值相等
-- 1 row affected: 表中没有冲突数据，数据被插入
-- 2 row affected: 表中有冲突数据，并且数据已经被更新

-- 通过 MySQL 函数获取受到影响的数据行数
mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           2 |
+-------------+
1 row in set (0.00 sec)
-- ON DUPLICATE KEY 当发生重复key的时候

6.1.4 替换-replace

mysql 复制代码

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

6.2 Retrieve(读取/筛选)

语法：

mysql 复制代码

SELECT 
 [DISTINCT] {* | {column [, column] ...} 
 [FROM table_name] 
 [WHERE ...] 
 [ORDER BY column [ASC | DESC], ...] 
 LIMIT ...

[DISTINCT]

可选关键字

用于消除结果集中的重复行，只返回唯一值

例：SELECT DISTINCT city FROM customers; 只返回不同的城市名

{* | {column [, column] ...}

指定要检索的列

* 表示选择所有列

也可以指定特定列名，多个列名用逗号分隔

例：SELECT first_name, last_name FROM employees;

[FROM table_name]

指定要从哪个表检索数据

可以是单个表、多个表（连接查询）或子查询

例：FROM customers 或 FROM orders JOIN customers ON orders.customer_id = customers.id

[WHERE ...]

可选子句，用于筛选符合特定条件的行

在这里可以使用各种条件表达式

例：WHERE age > 18 AND country = 'Canada'

[ORDER BY column [ASC | DESC], ...]

可选子句，用于对结果集进行排序

可以按一个或多个列排序

ASC：升序排列（默认）

DESC：降序排列

例：ORDER BY last_name ASC, first_name DESC

[LIMIT ...]

可选子句，用于限制返回的行数

可以指定一个值（最大行数）或两个值（偏移量和最大行数）

例：LIMIT 10（返回前10行）或 LIMIT 5, 10（跳过前5行，返回接下来的10行）

案例：

mysql 复制代码

-- 创建表结构 
mysql> CREATE TABLE exam_result ( 
    -> id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, 
    -> name VARCHAR(20) NOT NULL COMMENT '同学姓名', 
    -> chinese float DEFAULT 0.0 COMMENT '语文成绩', 
    -> math float DEFAULT 0.0 COMMENT '数学成绩', 
    -> english float DEFAULT 0.0 COMMENT '英语成绩' 
    -> ); 
Query OK, 0 rows affected (0.02 sec)
 
-- 插入测试数据 
mysql> INSERT INTO exam_result (name, chinese, math, english) VALUES 
    -> ('唐三藏', 67, 98, 56), 
    -> ('孙悟空', 87, 78, 77), 
    -> ('猪悟能', 88, 98, 90), 
    -> ('曹孟德', 82, 84, 67), 
    -> ('刘玄德', 55, 85, 45), 
    -> ('孙权', 70, 73, 78), 
    -> ('宋公明', 75, 65, 30); 
Query OK, 7 rows affected (0.00 sec)
Records: 7  Duplicates: 0  Warnings: 0

6.2.1 SELECT 列

6.2.1.1 全列查询

mysql 复制代码

-- 通常情况下不建议使用 * 进行全列查询 
-- 1. 查询的列越多，意味着需要传输的数据量越大； 
-- 2. 可能会影响到索引的使用。（索引待后面讲解） 
mysql> SELECT * FROM exam_result;
+----+-----------+---------+------+---------+
| id | name      | chinese | math | english |
+----+-----------+---------+------+---------+
|  1 | 唐三藏    |      67 |   98 |      56 |
|  2 | 孙悟空    |      87 |   78 |      77 |
|  3 | 猪悟能    |      88 |   98 |      90 |
|  4 | 曹孟德    |      82 |   84 |      67 |
|  5 | 刘玄德    |      55 |   85 |      45 |
|  6 | 孙权      |      70 |   73 |      78 |
|  7 | 宋公明    |      75 |   65 |      30 |
+----+-----------+---------+------+---------+
7 rows in set (0.00 sec)

6.2.1.2 指定列查询

mysql 复制代码

-- 指定列的顺序不需要按定义表的顺序来
mysql> SELECT id, name, english FROM exam_result;
+----+-----------+---------+
| id | name      | english |
+----+-----------+---------+
|  1 | 唐三藏    |      56 |
|  2 | 孙悟空    |      77 |
|  3 | 猪悟能    |      90 |
|  4 | 曹孟德    |      67 |
|  5 | 刘玄德    |      45 |
|  6 | 孙权      |      78 |
|  7 | 宋公明    |      30 |
+----+-----------+---------+
7 rows in set (0.00 sec)

6.2.1.3 查询字段为表达式

mysql 复制代码

-- 表达式不包含字段 
mysql> SELECT id, name, 10 FROM exam_result;
+----+-----------+----+
| id | name      | 10 |
+----+-----------+----+
|  1 | 唐三藏    | 10 |
|  2 | 孙悟空    | 10 |
|  3 | 猪悟能    | 10 |
|  4 | 曹孟德    | 10 |
|  5 | 刘玄德    | 10 |
|  6 | 孙权      | 10 |
|  7 | 宋公明    | 10 |
+----+-----------+----+
7 rows in set (0.00 sec)

mysql 复制代码

-- 表达式包含一个字段 
mysql> SELECT id, name, english + 10 FROM exam_result; 
+----+-----------+--------------+
| id | name      | english + 10 |
+----+-----------+--------------+
|  1 | 唐三藏    |           66 |
|  2 | 孙悟空    |           87 |
|  3 | 猪悟能    |          100 |
|  4 | 曹孟德    |           77 |
|  5 | 刘玄德    |           55 |
|  6 | 孙权      |           88 |
|  7 | 宋公明    |           40 |
+----+-----------+--------------+
7 rows in set (0.00 sec)

mysql 复制代码

-- 表达式包含多个字段 
mysql> SELECT id, name, chinese + math + english FROM exam_result; 
+----+-----------+--------------------------+
| id | name      | chinese + math + english |
+----+-----------+--------------------------+
|  1 | 唐三藏    |                      221 |
|  2 | 孙悟空    |                      242 |
|  3 | 猪悟能    |                      276 |
|  4 | 曹孟德    |                      233 |
|  5 | 刘玄德    |                      185 |
|  6 | 孙权      |                      221 |
|  7 | 宋公明    |                      170 |
+----+-----------+--------------------------+
7 rows in set (0.00 sec)

6.2.1.4 为查询结果指定别名

语法：

mysql 复制代码

SELECT column [AS] alias_name [...] FROM table_name;

SELECT: SQL查询的基本关键字，表示要检索数据。

column: 要检索的列名或表达式。

可以是表中的实际列名（如first_name）

可以是计算表达式（如price * quantity）

可以是函数结果（如COUNT(*)或CONCAT(first_name, ' ', last_name)）

[AS]: 可选关键字，用于引入别名。

AS关键字在大多数DBMS中可以省略

建议包含AS以提高可读性

alias_name: 为列指定的新名称（别名）。

如果别名包含空格或特殊字符，需要用引号括起来

常用双引号"alias name"或反引号alias name(MySQL)

[...]: 表示可以为多个列指定别名。

FROM table_name: 指定数据来源的表名。

mysql 复制代码

mysql> SELECT id, name, chinese + math + english 总分 FROM exam_result; 
+----+-----------+--------+
| id | name      | 总分   |
+----+-----------+--------+
|  1 | 唐三藏    |    221 |
|  2 | 孙悟空    |    242 |
|  3 | 猪悟能    |    276 |
|  4 | 曹孟德    |    233 |
|  5 | 刘玄德    |    185 |
|  6 | 孙权      |    221 |
|  7 | 宋公明    |    170 |
+----+-----------+--------+
7 rows in set (0.00 sec)

6.2.1.5 结果去重-distinct

mysql 复制代码

-- 98 分重复了 
mysql> SELECT math FROM exam_result;
+------+
| math |
+------+
|   98 |
|   78 |
|   98 |
|   84 |
|   85 |
|   73 |
|   65 |
+------+
7 rows in set (0.00 sec)

mysql 复制代码

-- 去重结果 
mysql> SELECT DISTINCT math FROM exam_result; 
+------+
| math |
+------+
|   98 |
|   78 |
|   84 |
|   85 |
|   73 |
|   65 |
+------+
6 rows in set (0.00 sec)