MySQL之束缚和表的增删查改

一.数据库束缚

1.1数据库束缚的概念

C++中对于我们定义的数据有着一套查抄的逻辑，当数据不符合你数据类型的范围时就会产生报错那么MySQL中是否也有这种设计呢？C++中对于数据的查抄一样寻常是编译器本身进行产生报错而MySQL则会通过束缚来让逼迫程序员本身正当插入数据。
数据库束缚是指对数据库表中的数据所施加的规则或条件，⽤于确保数据的准确性和可靠性。这
些束缚可以是基于数据类型、值范围、唯⼀性、⾮空等规则，以确保数据的正确性和相容性。简单来说束缚类似于我们的法律法规来让我们程序员本身服从，只要不违反这个规定MySQL就不会发出告诫。
例如我们之前先容MySQL中数据类型时提到过差别类型的取值范围这就算是一种束缚，只要我们插入的数据不符合这个范围MySQL也会发出告诫。
1.2NOT NULL 非空束缚

对于某些数据将其设为空是没有意义以是我们可以使用非空束缚来让其不可能为空。
例如对于门生来说他的名字学号身份证这些都不可能为空，也不会将其设为空由于如许就没有意义了。

从图片中我们也可以发现想要对某列加束缚的话我们只需要在创建表时在列后增加关键字即可，非空束缚就是not null。
想要判断表中某列是否可以为空我们只需要使用desc来检察表布局此中的NULL为yes则阐明可以为空no就是不可以。
1.3DEFAULT 默认束缚

我们同样可以为一列增加一个默认值类似于我们C++中的缺省参数，只要我们不显式设置列的值那么它就是默认值。

1.4唯一束缚

对于数据来说我们有时候需要它是不重复的以是我们也可以将一个列增加唯一束缚。这时候这列就被叫做唯一键。

1.5主键束缚和自增束缚

对于一个表来说我们有时候对于存储的数据我们是有轻重之分的，有些数据是这个表中最重要的数据例如门生表中的学号，即使其他的数据都为空工作人员也可以通过学号来找到一个门生。有些数据的存在又是比力无所谓的就像门生表中门生的爱好，这些数据就算不存在也不会影响什么。以是这些重要的数据我们需要来特别关注不能让它重复也不能为空，这就是主键。
主键束缚用来标明一张表中的每条记录，主键既不能为空也不能重复而且一个表中只能有一个主键而主键可以由一列或者多列构成。

主键同样可以设为多列此时只要多列的内容不是完全相同则不算是重复，但是多列中每一个的内容都不可以为空。

一个表中只能有一个主键

1.6自增束缚

由于主键是用来标识表中的每个记录以是它一样寻常搭配则自增束缚来使用，它允许数据库主动为新插入行的特定列生成一个唯一的数字。这通常用于主键列，以确保每条记录都有一个唯一的标识符。
由于只有数字可以自增以是自增列必须是整数类型而且只能用于键列即唯一键，主键或者外键同时一个表中只能设置一个自增列。

在一个键列被设为自增后我们仍然可以主动去设置它的值不过之后会在你设置的值的底子上进行自增。我们可以使用show create table table_name 来检察这个表的创建语句以及此时它的自增值是多少

1.7外键束缚

人与人之间是有联系的同理表与表之间也是有联系的例如我是二班的门生那么这里就会有两个表一个为班级表一个是二班的成员表。那么这两个表不就形成了一种主从关系，主表是班级表而从表就是各班的成员表也可以说从表是对主表中对应内容的扩展。以是主表和从表中可以通过两表中各自的一列创建联系就像班级表中的班级编号和成员表中的班级编号。

但是我们可以将从表中班级编号设为空来插入行

以是在使用外键束缚时我们需要留意：

• 主表和从表对应的列数据类型必须相同
  
• 在从表插入行时外键列的值必须在主表中存在或者为空
  
• 在删除主表中某行时从表不能存在对这行的引用
  
• 删除主表前必须删除从表
  

1.8CHECK束缚

可以应⽤于⼀个或多个列，⽤于限定列中可担当的数据值，从⽽确保数据的完整性和准确性。

二.表的增删查改

对数据库中表的内容做操纵一样寻常被分为四类：Create，Retrieve，Update，Delete，简称CRUD。
2.1Create创建

1. insert
2. [into]
3. table_name #表名
4. [(column [,column],...)] #是否指定列
5. values (vast_list) [,(vast_list)],...#插入的数据以行为单位
7. vast_list: value[,value] ...

复制代码

对于使用insert插入行我们可以完成单行数据全列插入，单行数据指定列插入以及多行数据指定列插入。

• 单行数据全列插入
  
  
  
  
• 单行数据指定列插入
  使用单行指定列插入时要留意没有被插入的列是否有非空束缚或者主键束缚以免出现报错
  
  
  
  
• 多行数据指定列插入
  使用多行数据指定列插入时要留意每行的数据要用()各自包裹起来。
  
  
  
  

2.2Retrieve读取

1. SELECT
2. [DISTINCT] #是否去重
3. select_expr [, select_expr] ... #读取的列
4. [FROM table_references] #是否从某个表中读取
5. [WHERE where_condition] #是否有判断条件
6. [GROUP BY {col_name | expr}, ...] #是否进行分表
7. [HAVING where_condition] #在完成读取后是否再进行条件判断
8. [ORDER BY {col_name | expr } [ASC | DESC], ... ] #是否进行排序
9. [LIMIT {[offset,] row_count | row_count OFFSET offset}] #限制返回记录数量

复制代码

在了解了语法后我们从简单的开始渐渐入手，用例子来为大家讲解语法中各个字段的作用
首先是最简单的查询，我们可以完成全列查询或者指定列查询亦或者我们可以查询一个表达式的结果。

• 全列查询
  
  
  
  
• 指定列查询
  
  
  
  
• 查询表达式结果
  
  
  
  这此中chinese+10就算是一个表达式，有了这项特性我们就可以利用这些琐屑的数据来完成需求例如我们想要知道总分。
  
  
  
  但是我们发现chinese+math+english的可读性也太差了以是我们还可以将这个表达式修改名称。
  
  
  
  

这就是最底子的查询工作接下来我们融合哪些可选性的字段来对查询进行升级

• [DISTINCT] #是否去重
  我们可以使用distinct来在查询的时候完成对表的去重
  
  
  
  在使用math的时候要留意只要表中有任何一列的内容是不重复的那就不会被去重，同时我也盼望大家可以明白表这个概念，表不光指存储在磁盘中数据库文件中的表文件，在MySQL中齐备都是表都可以当做表比如我们完成查询后输出的内容也是一个表只不过我们可以将其分为逻辑表以及存储表。对表的明白会影响到后续我们对复合查询以及表里毗连的明白。
  
• [WHERE where_condition] #是否有判断条件
  MySQL中我们一样可以在查询时进行条件判断来完成对数据的筛选工作，既然有判断功能那么我们就需要使用运算符，此中被分为两种：比力运算符和逻辑运算符。同时我们搭配例子来给大家阐明
  比力运算符：
  

运算符阐明>, >=, <, <=大于，大于等于，小于，小于等于=等于，对于NULL的比力不安全，比如NULL=NULL的结果一样为NULL<=>等于，对于NULL的比力是安全的，比如NULL <=>NULL的结果是TRUE!=,<>不等于value BETWEEN a0AND a1范围匹配，[a0, a1]，假如a0 <= value <= a1，返回TRUE或1，NOT BETWEEN则取反value IN (option, …假如value 在optoin列表中，则返回TRUE(1)，NOT IN则取反IS NULL是NULLIS NOT NULL不是NULLLIKE模糊匹配，%表示任意多个字符包括零个，_表示任意一个字符，NOT LIKE则取反

1. #英语成绩大于60分
2. mysql> select * from exam where english > 60;
3. +------+-----------+---------+------+---------+
4. | id   | name      | chinese | math | english |
5. +------+-----------+---------+------+---------+
6. |    2 | 孙悟空    |      87 |   78 |      77 |
7. |    3 | 猪悟能    |      88 |   98 |      90 |
8. |    4 | 曹孟德    |      82 |   84 |      67 |
9. |    6 | 孙权      |      70 |   73 |      78 |
10. +------+-----------+---------+------+---------+
11. 4 rows in set (0.00 sec)
13. #语文成绩大于英语成绩
14. mysql> select * from exam where chinese > english;
15. +------+-----------+---------+------+---------+
16. | id   | name      | chinese | math | english |
17. +------+-----------+---------+------+---------+
18. |    1 | 唐三藏    |      67 |   98 |      56 |
19. |    2 | 孙悟空    |      87 |   78 |      77 |
20. |    4 | 曹孟德    |      82 |   84 |      67 |
21. |    5 | 刘⽞德    |      55 |   85 |      45 |
22. |    7 | 宋公明    |      75 |   65 |      30 |
23. +------+-----------+---------+------+---------+
24. 5 rows in set (0.00 sec)
26. #总分大于200分
27. mysql> select id,name,chinese+math+english total from exam where chinese+math+english > 200;
28. +------+-----------+-------+
29. | id   | name      | total |
30. +------+-----------+-------+
31. |    1 | 唐三藏    |   221 |
32. |    2 | 孙悟空    |   242 |
33. |    3 | 猪悟能    |   276 |
34. |    4 | 曹孟德    |   233 |
35. |    6 | 孙权      |   221 |
36. +------+-----------+-------+
37. 5 rows in set (0.00 sec)
38. #注意：虽然我们给chinese+math+english重命名为total了但是这是在我们查询完成后输出表结构时完成的
39. #而where判断是在查询过程中进行的此时重命名并没有完成，所以我们仍然只能使用chinese+math+english来代表总分
41. #语文成绩在60到80分之间
42. mysql> select id,name,chinese from exam where chinese between 60 and 80;
43. +------+-----------+---------+
44. | id   | name      | chinese |
45. +------+-----------+---------+
46. |    1 | 唐三藏    |      67 |
47. |    6 | 孙权      |      70 |
48. |    7 | 宋公明    |      75 |
49. +------+-----------+---------+
50. 3 rows in set (0.00 sec)
52. #语文成绩在67，70，71，72，73中任意一个
53. mysql> select id,name,chinese from exam where chinese in (67,70,71,72,73);
54. +------+-----------+---------+
55. | id   | name      | chinese |
56. +------+-----------+---------+
57. |    1 | 唐三藏    |      67 |
58. |    6 | 孙权      |      70 |
59. +------+-----------+---------+
60. 2 rows in set (0.00 sec)
62. #名字是孙某某，某某可以是零个字也可以是一个两个多个
63. mysql> select id,name from exam where name like '孙%';
64. +------+-----------+
65. | id   | name      |
66. +------+-----------+
67. |    2 | 孙悟空    |
68. |    6 | 孙权      |
69. +------+-----------+
70. 2 rows in set (0.00 sec)
72. #名字是孙某，某只能是一个字
73. mysql> select id,name from exam where name like '孙_';
74. +------+--------+
75. | id   | name   |
76. +------+--------+
77. |    6 | 孙权   |
78. +------+--------+
79. 1 row in set (0.00 sec)

复制代码

逻辑运算符：
运算符阐明AND多个条件必须都为 TRUE(1)，结果才是 TRUE(1)OR任意一个条件为TRUE，结果都是TRUENOT条件为TRUE，结果为FALSE

1. #语文和英语成绩都大于80
2. mysql> select id,name,chinese,english from exam where chinese >80 and english > 80;
3. +------+-----------+---------+---------+
4. | id   | name      | chinese | english |
5. +------+-----------+---------+---------+
6. |    3 | 猪悟能    |      88 |      90 |
7. +------+-----------+---------+---------+
8. 1 row in set (0.00 sec)
10. #语文或者英语成绩大于80
11. mysql> select id,name,chinese,english from exam where chinese >80 or english > 80;
12. +------+-----------+---------+---------+
13. | id   | name      | chinese | english |
14. +------+-----------+---------+---------+
15. |    2 | 孙悟空    |      87 |      77 |
16. |    3 | 猪悟能    |      88 |      90 |
17. |    4 | 曹孟德    |      82 |      67 |
18. +------+-----------+---------+---------+
19. 3 rows in set (0.00 sec)
21. #语文成绩不大于80
22. mysql> select id,name,chinese,english from exam where  not chinese >80 ;
23. +------+-----------+---------+---------+
24. | id   | name      | chinese | english |
25. +------+-----------+---------+---------+
26. |    1 | 唐三藏    |      67 |      56 |
27. |    5 | 刘⽞德    |      55 |      45 |
28. |    6 | 孙权      |      70 |      78 |
29. |    7 | 宋公明    |      75 |      30 |
30. +------+-----------+---------+---------+
31. 4 rows in set (0.00 sec)

复制代码

• [HAVING where_condition] #在完成读取后是否再进行条件判断
  在where中我们提到过where是在查询过程中进行条件判断而having则是在查询完成后再进行条件判断，除了这方面差别例如运算符什么的都是相同的使用方式。
  

1. #总分超过200
2. #由于是在查询完成后进行判断所以having就可以使用列的别名来进行条件判断
3. mysql> select id,name,chinese+math+english total from exam having total > 200;
4. +------+-----------+-------+
5. | id   | name      | total |
6. +------+-----------+-------+
7. |    1 | 唐三藏    |   221 |
8. |    2 | 孙悟空    |   242 |
9. |    3 | 猪悟能    |   276 |
10. |    4 | 曹孟德    |   233 |
11. |    6 | 孙权      |   221 |
12. +------+-----------+-------+
13. 5 rows in set (0.00 sec)

复制代码

• [ORDER BY {col_name | expr } [ASC | DESC], … ] #是否进行排序
  想要进行排序时我们需要指出你想要进行排序的列而且也可以选择是升序照旧降序，此中ASC是升序，DESC是降序。MySQL默认是进行升序排序
  

1. #默认是升序
2. mysql> select * from exam  order by chinese;
3. +------+-----------+---------+------+---------+
4. | id   | name      | chinese | math | english |
5. +------+-----------+---------+------+---------+
6. |    5 | 刘⽞德    |      55 |   85 |      45 |
7. |    1 | 唐三藏    |      67 |   98 |      56 |
8. |    6 | 孙权      |      70 |   73 |      78 |
9. |    7 | 宋公明    |      75 |   65 |      30 |
10. |    4 | 曹孟德    |      82 |   84 |      67 |
11. |    2 | 孙悟空    |      87 |   78 |      77 |
12. |    3 | 猪悟能    |      88 |   98 |      90 |
13. +------+-----------+---------+------+---------+
14. 7 rows in set (0.00 sec)
16. #显式升序
17. mysql> select * from exam  order by chinese asc;
18. +------+-----------+---------+------+---------+
19. | id   | name      | chinese | math | english |
20. +------+-----------+---------+------+---------+
21. |    5 | 刘⽞德    |      55 |   85 |      45 |
22. |    1 | 唐三藏    |      67 |   98 |      56 |
23. |    6 | 孙权      |      70 |   73 |      78 |
24. |    7 | 宋公明    |      75 |   65 |      30 |
25. |    4 | 曹孟德    |      82 |   84 |      67 |
26. |    2 | 孙悟空    |      87 |   78 |      77 |
27. |    3 | 猪悟能    |      88 |   98 |      90 |
28. +------+-----------+---------+------+---------+
29. 7 rows in set (0.00 sec)
31. #降序
32. mysql> select * from exam  order by chinese desc;
33. +------+-----------+---------+------+---------+
34. | id   | name      | chinese | math | english |
35. +------+-----------+---------+------+---------+
36. |    3 | 猪悟能    |      88 |   98 |      90 |
37. |    2 | 孙悟空    |      87 |   78 |      77 |
38. |    4 | 曹孟德    |      82 |   84 |      67 |
39. |    7 | 宋公明    |      75 |   65 |      30 |
40. |    6 | 孙权      |      70 |   73 |      78 |
41. |    1 | 唐三藏    |      67 |   98 |      56 |
42. |    5 | 刘⽞德    |      55 |   85 |      45 |
43. +------+-----------+---------+------+---------+
44. 7 rows in set (0.00 sec)
46. #总成绩降序
47. mysql> select id,name,chinese+math+english total from exam order by total desc;
48. +------+-----------+-------+
49. | id   | name      | total |
50. +------+-----------+-------+
51. |    3 | 猪悟能    |   276 |
52. |    2 | 孙悟空    |   242 |
53. |    4 | 曹孟德    |   233 |
54. |    1 | 唐三藏    |   221 |
55. |    6 | 孙权      |   221 |
56. |    5 | 刘⽞德    |   185 |
57. |    7 | 宋公明    |   170 |
58. +------+-----------+-------+
59. 7 rows in set (0.00 sec)
60. #为什么这里我们又可以使用别名（给列重命名就是取别名）来进行排序了呢？
61. #这是因为排序是在查询之后完成的这时候别名也已经取好了自然可以使用了

复制代码

• [LIMIT {[offset,] row_count | row_count OFFSET offset}] #限定返回记录数目
  我们可以在查询完成后限定输出表的行数以及从哪行开始输出，直接上例子
  

1. #从0开始显式五行
2. mysql> select * from exam limit 5;
3. +------+-----------+---------+------+---------+
4. | id   | name      | chinese | math | english |
5. +------+-----------+---------+------+---------+
6. |    1 | 唐三藏    |      67 |   98 |      56 |
7. |    2 | 孙悟空    |      87 |   78 |      77 |
8. |    3 | 猪悟能    |      88 |   98 |      90 |
9. |    4 | 曹孟德    |      82 |   84 |      67 |
10. |    5 | 刘⽞德    |      55 |   85 |      45 |
11. +------+-----------+---------+------+---------+
12. 5 rows in set (0.00 sec)
14. #从2开始显示5行
15. #注意：表结构的行数是从0开始算的
16. mysql> select * from exam limit 2,5;
17. +------+-----------+---------+------+---------+
18. | id   | name      | chinese | math | english |
19. +------+-----------+---------+------+---------+
20. |    3 | 猪悟能    |      88 |   98 |      90 |
21. |    4 | 曹孟德    |      82 |   84 |      67 |
22. |    5 | 刘⽞德    |      55 |   85 |      45 |
23. |    6 | 孙权      |      70 |   73 |      78 |
24. |    7 | 宋公明    |      75 |   65 |      30 |
25. +------+-----------+---------+------+---------+
26. 5 rows in set (0.00 sec)
28. #从5开始显示两行
29. mysql> select * from exam limit 2 offset 5;
30. +------+-----------+---------+------+---------+
31. | id   | name      | chinese | math | english |
32. +------+-----------+---------+------+---------+
33. |    6 | 孙权      |      70 |   73 |      78 |
34. |    7 | 宋公明    |      75 |   65 |      30 |
35. +------+-----------+---------+------+---------+
36. 2 rows in set (0.00 sec)

复制代码

• [GROUP BY {col_name | expr}, …] #是否进行分表
  在一样平常中我们可能面对一些数据是可以根据某列划分成差别的组的，例如我们在工作中差别的部门学校中差别的班级都是这种情况。以是group by通常是被叫做分组但是大家还记得我之前说的MySQL中齐备都是表以是我觉得分表更加好明白，大家可以将其明白成根据某列将一个大表划分成几个小表但是它照旧个表。
  

1. mysql> select * from emp;
2. +----+-----------+--------+------------+
3. | id | name      | role   | salary     |
4. +----+-----------+--------+------------+
5. |  1 | 马云      | 老板   | 1500000.00 |
6. |  2 | 马化腾    | 老板   | 1300000.00 |
7. |  3 | 张三      | 经理   |   13000.00 |
8. |  4 | 赵四      | 经理   |   11000.00 |
9. |  5 | 王五      | 员工   |    5000.00 |
10. |  6 | 田七      | 员工   |    6000.00 |
11. |  7 | 路人甲    | 保安   |    2000.00 |
12. |  8 | 路人乙    | 保安   |    2000.00 |
13. +----+-----------+--------+------------+
14. 8 rows in set (0.00 sec)
16. #根据role来进行分表
17. mysql> select role from emp group by role;
18. +--------+
19. | role   |
20. +--------+
21. | 老板   |
22. | 经理   |
23. | 员工   |
24. | 保安   |
25. +--------+
26. 4 rows in set (0.00 sec)
28. #根据role分表后我们还可以通过聚合函数来对分表进行处理
29. mysql> select role,count(*) from emp group by role;
30. +--------+----------+
31. | role   | count(*) |
32. +--------+----------+
33. | 老板   |        2 |
34. | 经理   |        2 |
35. | 员工   |        2 |
36. | 保安   |        2 |
37. +--------+----------+
38. 4 rows in set (0.00 sec)
40. mysql> select role,max(salary),min(salary),avg(salary) from emp group by role;
41. +--------+-------------+-------------+----------------+
42. | role   | max(salary) | min(salary) | avg(salary)    |
43. +--------+-------------+-------------+----------------+
44. | 老板   |  1500000.00 |  1300000.00 | 1400000.000000 |
45. | 经理   |    13000.00 |    11000.00 |   12000.000000 |
46. | 员工   |     6000.00 |     5000.00 |    5500.000000 |
47. | 保安   |     2000.00 |     2000.00 |    2000.000000 |
48. +--------+-------------+-------------+----------------+
49. 4 rows in set (0.00 sec)

复制代码

2.3Update更新

1. UPDATE
2. [LOW_PRIORITY] #是否将updata设为低优先级操作
3. [IGNORE] #是否忽略遇到不可重复键时的错误
4. table_reference #表的名称
5. SET assignment [, assignment] ... #更新的内容
6. [WHERE where_condition] #是否进行条件判断
7. [ORDER BY ...] #是否进行排序
8. [LIMIT row_count] #是否控制输出的内容

复制代码

我们先举一些简单的例子来让大家知道怎么使用updata再讲解此中的比力重要的可选项。

1. mysql> select * from exam;
2. +------+-----------+---------+------+---------+
3. | id   | name      | chinese | math | english |
4. +------+-----------+---------+------+---------+
5. |    1 | 唐三藏    |      67 |   98 |      56 |
6. |    2 | 孙悟空    |      87 |   78 |      77 |
7. |    3 | 猪悟能    |      88 |   98 |      90 |
8. |    4 | 曹孟德    |      82 |   84 |      67 |
9. |    5 | 刘⽞德    |      55 |   85 |      45 |
10. |    6 | 孙权      |      70 |   73 |      78 |
11. |    7 | 宋公明    |      75 |   65 |      30 |
12. +------+-----------+---------+------+---------+
13. 7 rows in set (0.00 sec)
15. //给孙悟空的语文更新为30分
16. mysql> update exam set chinese = 30 where name = '孙悟空';
17. Query OK, 1 row affected (0.00 sec)
18. Rows matched: 1  Changed: 1  Warnings: 0
20. mysql> select * from exam where name = '孙悟空';
21. +------+-----------+---------+------+---------+
22. | id   | name      | chinese | math | english |
23. +------+-----------+---------+------+---------+
24. |    2 | 孙悟空    |      30 |   78 |      77 |
25. +------+-----------+---------+------+---------+
26. 1 row in set (0.00 sec)
28. //给曹孟德的英语更新为60数学更新为70
29. mysql> update exam set english = 60,math = 70 where name = '曹孟德';
30. Query OK, 1 row affected (0.01 sec)
31. Rows matched: 1  Changed: 1  Warnings: 0
33. mysql> select * from exam where name = '曹孟德';
34. +------+-----------+---------+------+---------+
35. | id   | name      | chinese | math | english |
36. +------+-----------+---------+------+---------+
37. |    4 | 曹孟德    |      82 |   70 |      60 |
38. +------+-----------+---------+------+---------+
39. 1 row in set (0.00 sec)
42. mysql> select id,name,math,chinese+math+english total from exam order by chinese+math+english asc;
43. +------+-----------+------+-------+
44. | id   | name      | math | total |
45. +------+-----------+------+-------+
46. |    5 | 刘⽞德    |  115 |   215 |
47. |    1 | 唐三藏    |   98 |   221 |
48. |    6 | 孙权      |   73 |   221 |
49. |    7 | 宋公明    |  125 |   230 |
50. |    4 | 曹孟德    |  100 |   242 |
51. |    2 | 孙悟空    |  138 |   245 |
52. |    3 | 猪悟能    |   98 |   276 |
53. +------+-----------+------+-------+
54. 7 rows in set (0.00 sec)
56. //给总分最低的三名数学各加30分
57. mysql> update exam set math =math + 30 where chinese+math+english is not null order by chinese+math+english  asc limit 3;
58. Query OK, 3 rows affected (0.00 sec)
59. Rows matched: 3  Changed: 3  Warnings: 0
61. mysql> select id,name,math,chinese+math+english total from exam order by chinese+math+english asc;
62. +------+-----------+------+-------+
63. | id   | name      | math | total |
64. +------+-----------+------+-------+
65. |    7 | 宋公明    |  125 |   230 |
66. |    4 | 曹孟德    |  100 |   242 |
67. |    2 | 孙悟空    |  138 |   245 |
68. |    5 | 刘⽞德    |  145 |   245 |
69. |    1 | 唐三藏    |  128 |   251 |
70. |    6 | 孙权      |  103 |   251 |
71. |    3 | 猪悟能    |   98 |   276 |
72. +------+-----------+------+-------+
73. 7 rows in set (0.00 sec)

复制代码

要留意在使用update时更新数据不能使用math += 30这种语法只能使用math = math + 30。而且我们使用update的时候一样寻常都是需要搭配where来进行条件判断的不然更新就会造成全列数据的改变以是要更新数据要慎重。
update的使用比力简单但是它的两个可选项是需要我们说一下的。

• [LOW_PRIORITY]
  这个可选项是是否将update以低优先度的方式进行，想要明白这个概念我们就需要先知道MySQL中优先度是如何进行设计的。从我们C++的履历中有优先级一样寻常我们都会涉及到锁的概念以是在MySQL中也不破例，当我们进行CURD时需要SQL先申请锁申请乐成之后才气进行操纵否则就需要等待。假如我们不设置锁让CURD随意进行那么在高并发的情况下MySQL写入和读取数据就会变得很杂乱可能此时我读取的数据是这个但是现实并不是如许的由于被其他人修改了，以是我们需要锁来完成MySQL中语句的调度。
  那么我们可以使用读写者模型来对表的增删查改进行分类，我们将select也就是读取作为读取者，而insert，update和delete都是写入者。MySQL中默认的调度是如许的：写入操纵优先级大于读取操纵，写入操纵在同一时刻只能发生一次而且写入哀求需要按时间来进行列队，读取操纵在可以多个同时进行的。而low_priority则是MySQL提供的更改调度策略的字段，在update后添加low_priority后就会将其的优先度调整的比读取操纵低这就会导致假如一直有读取操纵在进行由于update的优先度低以是它必须等全部的读取操纵完成后才气进行也就是将update阻塞住了。
  
• [IGNORE]
  这个可选项的作用是防止遇到不可重复键时的错误，我们知道表中有些列是不可重复键例如主键，唯一键，正常当我们使用update更新表中的数据时我们更新的数据假如原来的数据是重复的就会发生报错此时我们在update后添加IGNORE就会避免这个报错的产生。
  

2.4Delete删除和Truncate截断

1. DELETE
2. FROM
3. tbl_name #表名
4. [WHERE where_condition] #是否进行条件判断
5. [ORDER BY ...] #是否进行排序
6. [LIMIT row_count] #是否进行输出内容的控制

复制代码

删除我就不进行演示了只是大家要留意假如我们不加条件判断就会将整个表的数据删除了以是无论是更新照旧删除大家都最好加上where以防出现无法挽回的情况。

1. TRUNCATE [TABLE] tbl_name

复制代码

截断和删除差别截断只能对整个表进行它无法进行条件判断从而对某行来进行。不但如此截断尚有和删除差别的地方，我直接给大家上例子

1. mysql> select * from student;
2. +----+--------+------+
3. | id | name   | age  |
4. +----+--------+------+
5. |  1 | 张三   |   17 |
6. |  2 | 李四   |   18 |
7. |  3 | 王五   |   18 |
8. |  4 | 赵六   |   16 |
9. |  5 | 田七   |   16 |
10. |  6 | 刘八   |   16 |
11. |  7 | 杨九   |   16 |
12. +----+--------+------+
13. 7 rows in set (0.00 sec)
15. mysql> show create table student\G;
16. *************************** 1. row ***************************
17.        Table: student
18. Create Table: CREATE TABLE `student` (
19.   `id` bigint NOT NULL AUTO_INCREMENT,
20.   `name` char(8) NOT NULL,
21.   `age` int DEFAULT '16',
22.   PRIMARY KEY (`id`),
23.   CONSTRAINT `student_chk_1` CHECK ((`age` >= 16))
24. ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
25. 1 row in set (0.00 sec)
27. mysql> delete from student;
28. Query OK, 7 rows affected (0.01 sec)
30. mysql> show create table student\G;
31. *************************** 1. row ***************************
32.        Table: student
33. Create Table: CREATE TABLE `student` (
34.   `id` bigint NOT NULL AUTO_INCREMENT,
35.   `name` char(8) NOT NULL,
36.   `age` int DEFAULT '16',
37.   PRIMARY KEY (`id`),
38.   CONSTRAINT `student_chk_1` CHECK ((`age` >= 16))
39. ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
40. 1 row in set (0.00 sec)
42. mysql> insert into student (name) values('张三'),('李四');
43. Query OK, 2 rows affected (0.01 sec)
44. Records: 2  Duplicates: 0  Warnings: 0
46. mysql> select * from student;
47. +----+--------+------+
48. | id | name   | age  |
49. +----+--------+------+
50. |  8 | 张三   |   16 |
51. |  9 | 李四   |   16 |
52. +----+--------+------+
53. 2 rows in set (0.00 sec)

复制代码

大家如今把关注点转移到表的创建语句中我们可以发如今使用delete删除表的数据后表的auto_increment也就是自增值是没有被清零的这点我们在上面讲自增束缚的时候也提到过。如今我们去看看truncate的情况。

1. mysql> show create table student\G;
2. *************************** 1. row ***************************
3.        Table: student
4. Create Table: CREATE TABLE `student` (
5.   `id` bigint NOT NULL AUTO_INCREMENT,
6.   `name` char(8) NOT NULL,
7.   `age` int DEFAULT '16',
8.   PRIMARY KEY (`id`),
9.   CONSTRAINT `student_chk_1` CHECK ((`age` >= 16))
10. ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
11. 1 row in set (0.00 sec)
13. ERROR:
14. No query specified
16. mysql> select * from student;
17. Empty set (0.01 sec)
19. mysql> insert into student (name) values('张三'),('李四');
20. Query OK, 2 rows affected (0.01 sec)
21. Records: 2  Duplicates: 0  Warnings: 0
23. mysql> select * from student;
24. +----+--------+------+
25. | id | name   | age  |
26. +----+--------+------+
27. |  8 | 张三   |   16 |
28. |  9 | 李四   |   16 |
29. +----+--------+------+
30. 2 rows in set (0.00 sec)
32. mysql> truncate table student;
33. Query OK, 0 rows affected (0.02 sec)
35. mysql> select * from student;
36. Empty set (0.00 sec)
38. mysql> show create table student\G;
39. *************************** 1. row ***************************
40.        Table: student
41. Create Table: CREATE TABLE `student` (
42.   `id` bigint NOT NULL AUTO_INCREMENT,
43.   `name` char(8) NOT NULL,
44.   `age` int DEFAULT '16',
45.   PRIMARY KEY (`id`),
46.   CONSTRAINT `student_chk_1` CHECK ((`age` >= 16))
47. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
48. 1 row in set (0.00 sec)
50. mysql> insert into student (name) values('张三'),('李四');
51. Query OK, 2 rows affected (0.00 sec)
52. Records: 2  Duplicates: 0  Warnings: 0
54. mysql> select * from student;
55. +----+--------+------+
56. | id | name   | age  |
57. +----+--------+------+
58. |  1 | 张三   |   16 |
59. |  2 | 李四   |   16 |
60. +----+--------+------+
61. 2 rows in set (0.00 sec)

复制代码

大家可以发如今我们截断了表后不光表的数据被清空了表的自增值一样被清空了酿成从零开始了。而且TRUNCATE命令通常比DELETE命令更快，由于它不记录单个行的删除操纵。DELETE命令会为表中的每一行生成一个删除操纵，而TRUNCATE命令则一次性删除表中的全部数据，因此执行速度更快。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告