复习SQL语句:
1.建立数据库 create database：
create database test;
2.切换使用数据库 use：
use test;
3.如果有报错，看下warnings show：
show warning;
4.建立表如下 create table:
后面加defalut就初始化了默认值，否则为null（无）。注意无不是空格‘ ’ 看下图的表结构可以看出区别
CREATE TABLE test1
(
PersonID int default 0,
LastName varchar(255) default '',
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
5.查看表结构 describe:
注意红线处表示了有无default的区别
describe test1;
6.删除表 drop table：
drop table test1;
7.删除数据库 drop dataset：
drop database test;
8.插入行数据 insert into：
方法1：
insert into test1
values('11603009','Lucy','Cheng','JingAn Street','ShangHai');
方法2：
insert into test1(PersonID,LastName ,FirstName ,Address,City )
values('11603007','Candy','Lu','NanShan Street','ShenZhen');
可以打乱结构顺序：
insert into test1(FirstName ,Address,City,PersonID,LastName )
values('JingAn Street','ShangHai','11603009','Lucy','Cheng');
在指定的列插入数据，其他留空：
insert into test1(LastName ,FirstName )
values('Admin','Admin');
9.查看目前表里全部数据 select from：
select * from test1;
10.删除重复元素，保留order_id最小的元素：
1.找出哪些元素重复的需要删除：
例如此处id相同的就算重复，但是其他相同都不算重复，此时就按照id进行分组：
利用了关键词groupby
select PersonID, count(*) from test1 GROUP BY PersonID;
可以看到按照id分组了：
2.重复行的组大小大于1。使用HAVING子句只显示重复行：
select PersonID, count(*) from test1 GROUP BY PersonID having count(*)>1;
得到：
解惑:
1.为什么不能使用WHERE子句？
因为WHERE子句过滤的是分组之前的行，HAVING子句过滤的是分组之后的行。
这里的含义和执行顺序是：
按照personID分组，相同的分为一组，并计算出每个分组的数量，并且选择出count(*)大于1的组，最后选出PersonID和count(*)展示出结果。
执行顺序从后往前：
先执行GROUP BY PersonID，再执行：having count(*)>1，最后执行：select PersonID, count(*) from test1
3.删除重复行：
一种简单的方法是建立一个临时表，记录下需要删除的重复元素，只保留一个：
如果行完全一样，删除哪个就都无所谓了，这样就没什么意义了，而且选择的时候也不好进行选择，所以我们增加一个自增的主索引，达到区分每一行的目的：
查看当前表的索引:
show index from test1;
可以看到为空：
设置一个int类型的自增的主键（ primary key）：
alter table test1 add order_id int auto_increment primary key;
关键字alter可以插入列，自增索引必须是int类型。
再查看一下，可以看到主键的信息
注意主键不是index不能只删除索引，只能连着删除字段了。
alter table test1 drop order_id;
关于索引，主键和字段的区别，在mysql练习一的概念区有讲，这里不重复了。
现在查看一下表：
于是只保留order_id最小的那个值：
select PersonID , MIN(order_id),count(*) from test1 group by PersonID having count(*) > 1;
建立一个临时表：
create temporary table to_delete (PersonID int not null, min_id int not null);
只保留order_id最小的那个值，所以先保存最小的order_id：
insert into to_delete(PersonID , min_id)
select PersonID , MIN(order_id) from test1 group by PersonID having count(*) > 1;
联合对比两个表，并且进行删除：
delete from test1
where exists(
select * from to_delete
where to_delete.PersonID = test1.PersonID and test1.order_id<>to_delete.min_id
);
结果:
11.不能重复插入unique：
上面的表费了很大的力气去解决重复的问题，如果在插入的时候，就能检查出错误，那就省了很多时间和功夫。
所以这是数据库设计师的锅，设计的时候就该设计好：
创建带有主键和索引的表： 主键就限制不能重复了，索引是便于查找用的，有很多种索引，不同引擎用的底层算法也不一样。另外有些值不能为空，否则后续容易出错，这就要设置not NULL条件了。约束字段为自动增长，被约束的字段必须同时被key约束
CREATE TABLE test2
(
order_id int auto_increment primary key,
PersonID int default 0,
LastName varchar(255) default '' not null,
FirstName varchar(255)default '' not null,
Address varchar(255) not null,
City varchar(255) not null
);
这样设置之后，order_id每加上1就会索引自增1，
而且如果插入的数据缺少一些关键项，就会失败：
插入没有default的值，而又没有定义这个值，就会报错了。
insert into test2(LastName ,FirstName ) values('Admin','Admin');
而有default的值或者可以为null的值的话，就可以插入了
insert into test2(Address ,City) values('Tomorrow Road','Admin');
12. 加唯一限制条件的索引和外键
mysql> alter table 表名 add unique 索引名 (字段名);
例如：
alter table test1 add unique PersonID_index(PersonID);
查看一下效果：这样一来personID就唯一了。
尝试插入默认值失败了，因为personID 0已经被占用。
当然这里建表时的限制条件还可以加，例如：
create table test3
(
order_id int auto_increment primary key, # int类型的自增主键
PersonID int default 0, # 默认为0
Class varchar(255) default '' not null, # 非空默认为‘’
InSchoolDay datetime DEFAULT CURRENT_TIMESTAMP, # 默认值为当前插入时间
foreign key(PersonID ) references test1(PersonID #自己表中的PersonID 关联到test1中的PersonID,如果test1里没有personID就不能进行插入了
on update cascade #更新同步外键foreign key的PersonID
on delete cascade , #删除同步外键foreign key到PersonID
#这样一来，test1里和test3的条目就会同步删除和更新了
ChangeTime datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP# 默认值为当前插入时间和更改时间
);
无注释语句如下:
create table test4(
order_id int auto_increment primary key,
PersonID int default 0,
Class varchar(255) default '' not null,
InSchoolDay datetime default current_timestamp,
foreign key(PersonID) references test1(PersonID) on update cascade on delete cascade,
ChangeTime datetime default current_timestamp on update current_timestamp);
另外还可以加上check条件和constraint约束：
constraint check (City='ShenZhen' or 'ShangHai' or 'BeiJing')
注意:MySQL 所有的存储引擎都不支持 CHECK和constraint 约束，仅可用于Oracle
MySQL中可以写 CHECK 约束，但会忽略它的作用，因此 CHECK 并不起作用，因此实现对数据约束有两种方法：
- 在 MySQL 中约束，如使用
ENUM 类型或者触发器。 - 在应用程序里面对数据进行检查再插入。
查看表:describe test3;
根据表1里的personID试着插入一条：
insert into test3(PersonID ,Class )
values('11603009','Class One');
成功了！
如果表1里没这个人的id就会发生插入失败：
说到这里，应该明白了，外键就是放在另一个表的主键，
如果关联的那个表里没有这个项就会发生插入失败。如果有，才能正常插入；
insert into test3(PersonID ,Class )values('11603109','Class One');
得到两个项：
那么如果删除会发生什么呢？我们先对test1进行删除：
delete from test1
where PersonID='11603009';
可以看到，不仅test1里的内容被删除了，test3里的内容也没有了。
如果对test3进行删除：
delete from test3
where PersonID='11603007' and Class='Class Two';
可以看到，test1没有受到任何影响，而test3里的行被删除了。
如果没有对外键设置on update cascade和on delete cascade的话，数据库会简单地报错，而不是同步删除！
解惑：从约束角度看primary key字段的值不为空且唯一，那我们直接使用not null+unique不就可以了吗，要它干什么？
主键primary key是innodb存储引擎组织数据的依据，innodb称之为索引组织表，一张表中必须有且只有一个主键。
一个表中可以：
- 单列做主键
- 多列做主键（复合主键）
但凡创建表，我们就要注意啦：
| 1.必须有且只要一个主键 |
|---|
| 2.通常id字段被设置为主键 |
13.更新update set 和简单排序order by
update test1
set LastName='July',Address='Friend Road',PersonID='11603008',City='ShangHai',FirstName='Click'
where LastName='Admin' and FirstName='Admin';
test3插入两条
insert into test3(PersonID ,Class )values('11603007','Class One');
insert into test3(PersonID ,Class )values('11603006','Class Two');
更新test1里July的学号：
update test1
set PersonID='11603008'
where LastName='July';
注意，不能在test3里进行更新，因为PersonId是外键：
多在test1里插入几条信息：
insert into test1(PersonID,LastName ,FirstName ,Address,City )
values('11603009','Lucy','Cheng','JingAn Street','ShangHai');
insert into test1(PersonID,LastName ,FirstName ,Address,City )
values('11603010','Andy','Meng','HePing Road','BeiJing');
insert into test1(PersonID,LastName ,FirstName ,Address,City )
values('11603011','Mark','Lu','JingAn Street','ShangHai');
insert into test1(PersonID,LastName ,FirstName ,Address,City )
values('11603014','Ken','Wang','Merry Street','ShenZhen');
对姓氏进行排序:
select * from test1
order by FirstName;
14.别名用as：
把查找到的PersonId改叫studentID：
select PersonID as StudentID from test1;
这在做内连接inner join或者是用in关键字时很有效，不会弄错。
而表的改名则利于缩短拼写，例如test1缩写为t1，test2缩写为t2，
则如果要查找来自上海的同学的地址和班级，则有:
select t1.Address,t2.Class
from
test1 as t1,
test3 as t2
where t1.PersonID=t2.PersonID and City= 'ShangHai';
也可以用in的语句来代替：（请尝试一下自己写！）
我得到了下面的结果：
select Address,Class
from test1 join test3
where test1.PersonID
in (select test1.PersonID
from test1
where City='ShangHai');
请思考一下这样会得到什么样的结果！！！！！！！！！
这样写出来的是错的，得到的是两个表全连接后的结果:
IN 操作符允许您在 WHERE 子句中规定多个值。
等价于多个‘=’的或的和，而上面的例子里可以看到，得到了三个PersonID满足条件:
而Class信息在表test3，Address信息在test1，
如果使用语句
select Address,Class from test1,test3;
就得到了了36个条目，
所以正确的写法如下：
select Address,Class
from test1,test3
where test1.PersonID =test3.PersonID
and test1.PersonID
in (select test1.PersonID from test1 where City='ShangHai');
首先限制了test1.PersonID=test3.PersonID，这样就滤去了两个表相乘或者说全连接得到的多余的不合法项，因为personID是两个表共有的而且是主键外键关系。
有些语句是多种写法可以相互替换的，有些则是不可以的，有些替换起来很麻烦，不过条条大路通罗马。
这个还可以用inner join内连接或者join（他们等价）来写：
select Address,Class
from test1
inner join test3
on test1.PersonID=test3.PersonID and City='ShangHai';
得到结果：
解惑：关于join用on还是用where的区别:
在使用 join 时，on 和 where 条件的区别如下：
- on 条件是在生成临时表时使用的条件，它不管 on 中的条件是否为真，都会返回左边表中的记录。
- where 条件是在临时表生成好后，再对临时表进行过滤的条件。这时已经没有 left join 的含义（必须返回左边表的记录）了，条件不为真的就全部过滤掉。
参考网址： 在使用 join 时，on 和 where 条件的区别
结论：
full 则具有 left 和 right 的特性的并集。 而 inner join 没这个特殊性，则条件放在 on 中和 where 中，返回的结果集是相同的。
15.联合 Union
当两个表中有相同含义的项时，UNION 操作符用于合并两个或多个 SELECT 语句的结果集。
请注意，UNION 内部的每个 SELECT 语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时，每个 SELECT 语句中的列的顺序必须相同。
union不含重复，union all则含有重复。
举个简单的例子：
select PersonID from test1
union
select PersonID from test3;
而union all含有重复项：
此处举个不恰当的例子：
说明了只要数据类型相同，就可以union
16.复制表 insert into… select from
删除表2的多余内容：
delete from test2 where order_id>2;
进行复制插入：
insert into test2(PersonID,LastName,FirstName,Address,City,order_id)
select * from test1
where order_id >4;
17.创建索引：create index
create index 语句用于在表中创建索引。
在不读取整个表的情况下，索引使数据库应用程序可以更快地查找数据。在表中创建索引，以便更加快速高效地查询数据。用户无法看到索引，它们只能被用来加速搜索/查询。
注释：更新一个包含索引的表需要比更新一个没有索引的表花费更多的时间，这是由于索引本身也需要更新。因此，理想的做法是仅仅在常常被搜索的列（以及表）上面创建索引。
create unique index pid_index on test1(PersonID);
create index pid_index2 on test1(PersonID);
创建unique索引出现了warnings，可以看到：
可能是因为这个项不是主键而且也没有设置unique属性。
show index from test1;
可以看到当前表的索引（主键自身就是一个默认的索引）
18.视图View：视图相当于将查询进行封装
在 SQL 中，视图是基于 SQL 语句的结果集的可视化的表。视图包含行和列，就像一个真实的表。视图中的字段就是来自一个或多个数据库中的真实的表中的字段。可以向视图添加 SQL 函数、WHERE 以及 JOIN 语句，也可以呈现数据，就像这些数据来自于某个单一的表一样。
可以想象视图是一个巨大的表的某些列和某些行，是原表的缩小版，更改原表，视图里的信息也变了。
对深圳人的姓名创建一个视图并查看:
create view name_view
as select FirstName,LastName
from test1 where City='ShenZhen';
19.使用 ENUM 类型 或者 触发器 。
单独开一个讲这两个：
传送连接：【mysql练习三】使用 ENUM 类型 或者 触发器
自测：
自测题1：
有test1和test3表如下:
在test1中对深圳或者上海人的LastName排序，只显示LastName和城市信息：
（自己输入一下语句做做练习吧！）
答案查看目录答案1
提示：order by 、or、 select
自测题2：
查看test1表中共有哪几个城市，不要显示重复城市：
提示：distinct
自测题3：
查看test1表中每个城市有多少人：
提示：group by，count()
自测题4：
先往test3里插入四条信息：
insert into test3(PersonID ,Class )values('11603009','Class One');
insert into test3(PersonID ,Class )values('11603010','Class One');
insert into test3(PersonID ,Class )values('11603014','Class One');
insert into test3(PersonID ,Class )values('11603011','Class Two');
查看最先入学的人的班级.
提示：可以有多种方法，但是他们的复杂度可能不一样
自测题5：
查找居住地含有‘Street’的人的姓名：
提示：like
自测题6：
查找名称首字母不以A-C开头的人的LastName：
提示：regexp
自测题7：
查找班级为Class One的所有人的名字：
提示：IN 与 = 的异同
相同点： 均在WHERE中使用作为筛选条件之一、均是等于的含义
不同点： IN可以规定多个值，等于规定一个值
这里有多种解法，可以用in也可以用join
自测题8：
查找入学日期在2020年4月2日18：00到18：30的不是北京和广东的学生的LastName和FirstName：
提示：not in、between and
自测题9：
下面有学生的各科分数表grade:
create table grade(
order_id int auto_increment primary key,
PersonID int default 0,
Math int default 0,
Chinese int default 0,
English int default 0,
Physics int default 0,
foreign key(PersonID) references test1(PersonID) on update cascade on delete cascade
);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603009',120,118,138,50);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603007',110,106,114,73);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603008',90,98,148,82);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603010',125,111,126,55);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603011',98,123,121,92);
insert into grade(PersonID,Math,Chinese,English,Physics) values('11603014',104,131,116,75);
1.查询年级各科目平均分，
2.查找各科最高分的同学的名字（FirstName+LastName）
3.查询各个同学的总分，并按照学号排序
4.查找每个班级有一或者科目不及格（语文数学英语<90,物理小于60）的不及格人数
5.对班级1的同学的成绩建立视图，计算班级平均分和最高分，创建视图，求均值和最大值分开写成三句。
6.查看总分大于430的同学所在的班级号，如果没有这个同学，输出空
答案：
答案1：
select LastName,City # 只要LastName和城市信息：
from test1 # 从表test1选择
where City='ShangHai'or City='ShenZhen' # 只要深圳或者上海人
order by LastName; # 按照LastName排序
得到：
答案2：
select distinct city
from test1;
得到
答案3：
select count(*),city
from test1
group by city;
得到
答案4:
1.利用min()函数查找，复杂度1
select class,min(InSchoolDay) from test3 ;
不过这样就少了一条，因为有两个人同时入学了。
2.先排序再取最前的几个值（复杂度：排序+选择 = o(nlogn)）
select class,InSchoolDay
from test3
order by InSchoolDay
limit 1;
注意： 当表过大或者是有很多条目的时候，如果只需要前面的几条，可以用关键字limit来限制数量。
3.目前想到的最优解
select class,inschoolday
from test3
where inschoolday
in(select min(inschoolday)
from test3);
先利用子查询：select min(inschoolday) from test3
得到了最小的入学日期集合{ 2020-04-02 18:24:50}：，然后对test3中入学日期在这个最小入学日期的集合（这个集合只有一个数）中的日期全部选出，然后显示班级和日期，可以看到效果如下：
答案5：
select FirstName,LastName
from test1
where address
like '%Street%';
like关键字+%通配符
| % | 替代 0 个或多个字符 |
|---|---|
| _ | 替代一个字符 |
| ^或者！ | 不在字符列中的任何单一字符 |
答案6：
select * from test1 where LastName regexp '^[^A-C]';
如果题目是LastName可以是A-C：
regexp是正则表达式的意思，后面的^[A-C]表示^是正则表达式开头符号，[A-C]表示可以是A、B、C，
关于正则这里不多叙述，可以看这个：正则表达式符号手册
答案7：
select FirstName,LastName
from test1
where PersonID
in(select PersonID
from test3
where Class='Class one');
这里要使用两个表连查，首先从test3表里找出满足班级是Class One的人的学号组，然后再从test1中找满足学号相等的全部的组。
或者可以直接用join：
select FirstName,LastName
from test1
inner join test3
on test1.PersonID=test3.PersonID
and Class='Class One'
order by FirstName;
这里我对FirstName进行了一下排序方便看
SQL JOIN 子句用于把来自两个或多个表的行结合起来，基于这些表之间的共同字段。
最常见的 JOIN 类型：SQL INNER JOIN（简单的 JOIN）。 SQL INNER JOIN 从多个表中返回满足 JOIN 条件的所有行。
| Join类型 | 含义 |
|---|---|
| INNER JOIN | 如果表中有至少一个匹配，则返回行 |
| LEFT JOIN | 即使右表中没有匹配，也从左表返回所有的行 |
| RIGHT JOIN | 即使左表中没有匹配，也从右表返回所有的行 |
| FULL JOIN | 只要其中一个表中存在匹配，则返回行 |
可以看到，左连接返回了全部左表（test1）里的值，右连接返回了全部右表（test3）里的值，由于左表中有两行不匹配，所以多出了两行NULL。
外连接就好像是为非基准表添加了一行全为空值的万能行，用来与基准表中找不到匹配的行进行匹配。假设两个没有空值的表进行左连接，左表是基准表，左表的所有行都出现在结果中，右表则可能因为无法与基准表匹配而出现是空值的字段。
而全连接呢？mysql是不支持full join的，但仍然可以同过左外连接+ union+右外连接实现，不知道8.01版本是否有做实现。
测试了一下感觉好像是‘乘’的效果
答案8：
select LastName,FirstName
from test1,test3
where test1.PersonID=test3.PersonID and
InSchoolDay between '2020-04-02 18:00:00'
and '2020-04-02 18:30:00'
and City not in ('BeiJing','GuangDong');
得到结果：
答案9：
1.查询年级各科目平均分：
select avg(Math), avg(Chinese), avg(English), avg(Physics)
from grade;
2.查找各科最高分的同学的名字（FirstName+LastName）
方法一：
select FirstName,LastName from test1 where personID
in (select personID from grade where Math =( select max(Math) from grade)
union select personID from grade where Chinese =( select max(Chinese) from grade)
union select personID from grade where English =( select max(English) from grade)
union select personID from grade where Physics =( select max(Physics) from grade) );
利用select personID from grade where Math =( select max(Math) from grade语句联合得到四个科目的最高分的同学的ID，然后再利用PersonID在test1单个表里查名字。
拓展：
1.如果想查询各科最高分的同学的学号和该科成绩max_grade,应该如何查询呢？
select personID,max(Math)
as max_grade from grade where Math in( select max(Math) from grade)
union select personID,max(Chinese) as max_grade from grade where Chinese in( select max(Chinese) from grade)
union select personID,max(English) as max_grade from grade where English in( select max(English) from grade)
union select personID,max(Physics) as max_grade from grade where Physics in( select max(Physics) from grade)
2.如果想查询各科最高分的同学的名字和该科成绩，如何查询？
select FirstName,LastName,max_grade from(
select personID,max(Math) as max_grade from grade where Math in( select max(Math) from grade)
union select personID,max(Chinese) as max_grade from grade where Chinese in( select max(Chinese) from grade)
union select personID,max(English) as max_grade from grade where English in( select max(English) from grade)
union select personID,max(Physics) as max_grade from grade where Physics in( select max(Physics) from grade))
as max_table,test1
where test1.PersonID=max_table.personID;
结果：
其实思路是一样的：先得到四个最高分者的PersonID和最高分，把最高分数的结果重命名为max_grade,得到一个表命名为max_table然后和test1表联合，就得到了结果。
max_table:
3.查询各个同学的总分，并按照学号排序:
select PersonID,Math+Chinese+Physics+English
from grade
order by PersonID;
注意：sum()是对列做加法，不是对行！！
4.查找每个班级有一或者科目不及格（语文数学英语<90,物理小于60）的不及格人数
select count(*),class
from test3,grade
where grade.PersonId=test3.personID
and (Math<90 or Chinese<90 or Physics<60 or English<90)
group by Class;
拓展：
查找每个班级没达到优秀的科目数（语文数学英语<120,物理小于80）
select class,count(*) from
(select personID from grade where Chinese<120
union all select personID from grade where English<120
union all select personID from grade where Math<120
union all select personID from grade where Physics<90)
as grade_id,test3
where test3.PersonID=grade_id.PersonID
group by class;
联合union alll全部的满足条件的id，然后按照班级进行分组group by
注意不要用union，因为会排除重复。
5.对班级1的同学的成绩建立视图，计算班级平均分和最高分：
create view class_one
as select grade.PersonID, Math,Chinese,English,Physics
from grade,test3
where test3.PersonID=grade.PersonID and Class='Class One';
计算平均值和最大值：
select avg(Math),avg(Chinese),avg(English),Avg(Physics) from class_one;
select max(Math),max(Chinese),max(English),max(Physics) from class_one;
6.查看总分大于430的同学所在的班级号，如果没有这个同学，输出空
select FirstName,LastName
from test1 where
Exists (select PersonID
from grade where Math+Chinese+English+Physics>430
and test1.PersonID=grade.PersonID );
