Test 表 
 id epid name suject score 
 1 1 张小三 技术 89 
 2 1 张小三 理论 70 
 3 1 张小三 效率 79 
 4 2 李小四 技术 89 
 5 2 李小四 效率 30 
 6 2 李小四 理论 50
 
 
关键字 
 DESC 降序 
 ASC 升序 
 SUM() 统计函数
 
计算每个员工的总分并排名（要求显示字段：姓名、总成绩） 降序
 
SELECT SUM(score), epid,name FROM test GROUP BY epid, name ORDER BY SUM(score) Desc

SELECT name AS 姓名,SUM(score) AS 总成绩 FROM test GROUP BY epid ORDER BY SUM(score) Desc

SELECT name,SUM(score) FROM test GROUP BY name ORDER BY SUM(score) Desc
 
计算每个员工的总分并排名（要求显示字段：工号、姓名、总成绩） 降序
 
SELECT epid AS 工号,name AS 姓名,SUM(score) AS 总成绩 FROM test GROUP BY epid ORDER BY SUM(score) Desc
 
计算每个员工的总分并排名（要求显示字段：工号、姓名、总成绩） 升序
 
 
这块有点疑问？ASC 为升序，为什么在中文姓名排序时变成了降序
 
SELECT epid AS 工号,name AS 姓名,SUM(score) AS 总成绩 FROM test GROUP BY epid ORDER BY SUM(score) ASC
 
计算每个员工的总分并排名（要求显示字段：工号、姓名、总成绩） 按中文姓名首字排序 降序 
 
SELECT epid AS 工号,name AS 姓名,SUM(score) AS 总成绩 FROM test GROUP BY epid ORDER BY name ASC
 
计算每个员工的总分并排名（要求显示字段：工号、姓名、总成绩） 按中文姓名首字排序 升序
 
SELECT epid AS 工号,name AS 姓名,SUM(score) AS 总成绩 FROM test GROUP BY epid ORDER BY name DESC
 

mysql的查询、子查询及连接查询
 
一、mysql查询的五种子句
 
where子句（条件查询）：按照“条件表达式”指定的条件进行查询。
 
group by子句（分组）：按照“属性名”指定的字段进行分组。group by子句通常和count()、sum()等聚合函数一起使用。
 
having子句（筛选）：有group by才能having子句，只有满足“条件表达式”中指定的条件的才能够输出。
 
order by子句（排序）：按照“属性名”指定的字段进行排序。排序方式由“asc”和“desc”两个参数指出，默认“asc”s升序来排
 
limit（限制结果集）。
 
 
 
1、where——基础查询
 
where常用运算符：
 
1.比较运算符
 <    小于
 <=    小于或等于
 =    等于
 != 或 <>    不等于
 >=    大于等于
 >    大于
 in    在某集合内
 between    在某范围内
 
2. 逻辑运算符
 not 或 !    逻辑非
 or 或 ||    逻辑或
 and 或 &&    逻辑与
 
2、group by 分组
 
“Group By”从字面意义上理解就是根据“By”指定的规则对数据进行分组，所谓的分组就是将一个“数据集”划分成若干个“小区域”，然后针对若干个“小区域”进行数据处理。
 
select 类别, sum(数量) as 数量之和
from A
group by 类别
 
注：group by语句中select指定的字段必须是“分组依据字段”，其他字段若想出现在select中则必须包含在聚合函数中。
 
mysql中五种常用的聚合函数：
 
（1）max(列名)：求最大值。
 
（2）min(列名)：求最小值。
 
（2）sum(列名)：求和。
 
（4）avg(列名)：求平均值。
 
（5）count(列名)：统计记录的条数。
 
3、having
 
having子句可以让我们筛选成组后的各种数据，where子句在聚合前先筛选记录，也就是说作用在group by和having子句前。而 having子句在聚合后对组记录进行筛选。 
 
示例：
 
select 类别, sum(数量) as 数量之和 from A
group by 类别
having sum(数量) > 18
 
示例：Having和Where的联合使用方法
 
select 类别, SUM(数量)from A
where 数量 >8
group by 类别
having SUM(数量) >10
 
where和having的区别：
 
作用的对象不同。WHERE 子句作用于表和视图，HAVING 子句作用于组。
 WHERE 在分组和聚集计算之前选取输入行（因此，它控制哪些行进入聚集计算）， 而 HAVING 在分组和聚集之后选取分组的行。因此，WHERE 子句不能包含聚集函数； 因为试图用聚集函数判断那些行输入给聚集运算是没有意义的。 相反，HAVING 子句总是包含聚集函数。（严格说来，你可以写不使用聚集的 HAVING 子句， 但这样做只是白费劲。同样的条件可以更有效地用于 WHERE 阶段。）
 在上面的例子中，我们可以在 WHERE 里应用数量字段来限制，因为它不需要聚集。 这样比在 HAVING 里增加限制更加高效，因为我们避免了为那些未通过 WHERE 检查的行进行分组和聚集计算。
综上所述：
 having一般跟在group by之后，执行记录组选择的一部分来工作的。where则是执行所有数据来工作的。
 再者having可以用聚合函数，如having sum(qty)>1000
 
例子：where + group by + having + 函数 综合查询
 
练习表：
 
CREATE TABLE "tb_stu" (
   "id" INT(3) DEFAULT NULL,
   "name" VARCHAR(15) DEFAULT NULL,
   "subject" VARCHAR(15) DEFAULT NULL,
   "score" INT(3) DEFAULT NULL
 ) 
 
INSERT INTO tb_stu VALUES(1,'张三','数学',90);
 INSERT INTO tb_stu VALUES(2,'张三','语文',50);
 INSERT INTO tb_stu VALUES(3,'张三','地理',40);
 INSERT INTO tb_stu VALUES(4,'李四','政治',45);
 INSERT INTO tb_stu VALUES(5,'李四','语文',55);
 INSERT INTO tb_stu VALUES(6,'王五','政治',30);
 INSERT INTO tb_stu VALUES(7,'王五','语文',70);
 
 
题目： 查询出两门及两门以上不及格者的平均成绩(注意是所有科目的平均成绩)
 
错误情况1：题意理解错误，理解成查出不及格科目的平均成绩。
 
 
错误情况2：count()不正确，SQL错误。
 
 
count(a),无论a是什么，都只是数一行；count时，每遇到一行，就数一个a，跟条件无关！
 
正解：count(score<60)达不到想要的结果，并不是条件的问题，而是无论count()里的表达式是什么都会数一行。score<60 返回 1 或 0；所以可以用sum(score<60)来计算不及格的科目数！
 
 
4、order by 排序
 
（1）order by price  //默认升序排列
 （2）order by price desc //降序排列
 （3）order by price asc //升序排列，与默认一样
 （4）order by rand() //随机排列，效率不高
 
5、limit
 
limit [offset,] N
 offset 偏移量，可选，不写则相当于limit 0,N
 N  取出条目
 
示例：取价格第4-6高的商品
 
select good_id,goods_name,goods_price from goods order by good_price desc limit 3,3;
 
总结：
 
select子句顺序
 
 
二、mysql子查询
 
1、where型子查询（把内层查询结果当作外层查询的比较条件）
 
（1）查询id最大的一件商品(使用排序+分页实现)
 
SELECT goods_id,goods_name,shop_price FROM goods ORDER BY goods_id DESC LIMIT 1;
 
（2）查询id最大的一件商品(使用where子查询实现)
 
SELECT goods_id,goods_name,shop_price FROM goods WHERE goods_id = (SELECT MAX(goods_id) FROM goods);
 
（3）查询每个类别下id最大的商品(使用where子查询实现)
 
SELECT goods_id,goods_name,cat_id,shop_price FROM goods WHERE goods_id IN (SELECT MAX(goods_id) FROM goods GROUP BY cat_id);
 
2、from型子查询(把内层的查询结果当成临时表，供外层sql再次查询。查询结果集可以当成表看待。临时表要使用一个别名。)
 
（1）查询每个类别下id最大的商品(使用from型子查询)
 
 SELECT goods_id,goods_name,cat_id,shop_price FROM
(SELECT goods_id,goods_name,cat_id,shop_price FROM goods ORDER BY cat_id ASC,goods_id DESC) AS tmp
GROUP BY cat_id;
 
子查询查出的结果集看第二张图，可以看到每个类别的第一条的商品id都为该类别下的最大值。然后将这个结果集作为一张临时表，巧妙的使用group by 查询出每个类别下的第一条记录，即为每个类别下商品id最大。
 
 
 
 
3、exists型子查询（把外层sql的结果，拿到内层sql去测试，如果内层的sql成立，则该行取出。内层查询是exists后的查询。）
 
（1）从类别表中取出其类别下有商品的类别(如果该类别下没有商品，则不取出)[使用where子查询]
 
SELECT c.cat_id,c.cat_name FROM category c WHERE c.cat_id IN (SELECT g.cat_id FROM goods g GROUP BY g.cat_id);
 
（2）从类别表中取出其类别下有商品的类别(如果该类别下没有商品，则不取出)[使用exists子查询]
 
 SELECT c.cat_id,c.cat_name FROM category c WHERE EXISTS (SELECT 1 FROM goods g WHERE g.cat_id = c.cat_id);
 
exists子查询，如果exists后的内层查询能查出数据，则表示存在；为空则不存在。
 
 
三、连接查询
 
学习连接查询，先了解下"笛卡尔积"，看下百度给出的解释：
 
 
      在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。表之间作联合查询即是作笛卡尔乘积，比如A表有5条数据，B表有8条数据，如果不作条件筛选，那么两表查询就有 5 X 8 = 40 条数据。
 
先看下用到的测试表基本信息：我们要实现的功能就是查询商品的时候，从类别表将商品类别名称关联查询出来。
 
行数：类别表14条，商品表4条。
 
 
结构：商品表和类别表都有一个cat_id
 
 
1、全相乘(不是全连接、连接查询)，全相乘是作笛卡尔积
 
两表全相乘，就是直接从两张表里查询；从查询的截图看出，总共查出了 4 X 14 = 56 条记录，这些记录是笛卡尔乘积的结果，即两两组合；
 
但我们要的是每个商品信息显示类别名称而已，这里却查出了56条记录，其中有52条记录都是无效的数据，全相乘的查询效率低。
 
SELECT goods_id,goods_name,cat_name FROM mingoods,category;
 
 
如果在两张表里有相同字段，做联合查询的时候，要区别表名，否则会报错误(模糊不清)。
 
SELECT goods_name,cat_id,cat_name FROM mingoods,category;　
 
 
       添加条件，使两表关联查询，这样查出来就是商品和类别一一对应了。虽然这里查出来4条记录，但是全相乘效率低，全相乘会在内存中生成一个非常大的数据(临时表)，因为有很多不必要的数据。
 
　   如果一张表有10000条数据，另一张表有10000条数据，两表全相乘就是100W条数据，是非常消耗内存的。而且，全相乘不能好好的利用索引，因为全相乘生成一张临时表，临时表里是没有索引的，大大降低了查询效率。
 
SELECT g.goods_name,g.cat_id AS g_cat_id, c.cat_id AS c_cat_id, c.cat_name FROM mingoods g, category c WHERE g.cat_id = c.cat_id;
 
 
2、左连接查询 left join ... on ...
 
语法：
 
select A.filed, [A.filed2, .... ,] B.filed, [B.filed4...,] from <left table> as A  left join <right table> as B on <expression>
 
假设有A、B两张表，左连接查询即 A表在左不动，B表在右滑动，A表与B表通过一个关系来关联行，B表去匹配A表。
 
2.1、先来看看on后的条件恒为真的情况
 
SELECT g.goods_name,g.cat_id, c.cat_id ,c.cat_name FROM mingoods g LEFT JOIN category c ON 1;
 
     跟全相乘相比，从截图可以看出，总记录数仍然不变，还是 4 X 14 = 56 条记录。但这次是商品表不动，类别表去匹配，因为每次都为真，所以将所有的记录都查出来了。左连接，其实就可以看成左表是主表，右表是从表。
 
 
2.2 、根据cat_id使两表关联行
 
SELECT g.goods_name,g.cat_id,c.cat_id,c.cat_name FROM mingoods g LEFT JOIN category c ON g.cat_id = c.cat_id;
 
使用左连接查询达到了同样的效果，但是不会有其它冗余数据，查询速度快，消耗内存小，而且使用了索引。左连接查询效率相比于全相乘的查询效率快了10+倍以上。
 
　　左连接时，mingoods表(左表)不动，category表(右表)根据条件去一条条匹配，虽说category表也是读取一行行记录，然后判断cat_id是否跟mingoods表的相同，但是，左连接使用了索引，cat_id建立了索引的话，查询速度非常快，所以整体效率相比于全相乘要快得多，全相乘没有使用索引。
 
 
2.3、查询出第四个类别下的商品，要求显示商品名称
 
SELECT g.goods_name,g.cat_id,c.cat_name,g.shop_price FROM goods g LEFT JOIN category c ON g.cat_id = c.cat_id WHERE g.cat_id = 4;
 
 
2.4 、对于左连接查询，如果右表中没有满足条件的行，则默认填充NULL。
 
SELECT g.goods_name,g.cat_id AS g_cat_id, c.cat_id AS c_cat_id,c.cat_id FROM mingoods g LEFT JOIN mincategory c ON g.cat_id = c.cat_id;
 
 
3、右连接查询 right join ... on ...
 
语法：
 
select A.field1,A.field2,..., B.field3,B.field4  from <left table> A right join <right table> B on <expression>
 
右连接查询跟左连接查询类似，只是右连接是以右表为主表，会将右表所有数据查询出来，而左表则根据条件去匹配，如果左表没有满足条件的行，则左边默认显示NULL。左右连接是可以互换的。
 
SELECT g.goods_name,g.cat_id AS g_cat_id,  c.cat_id AS c_cat_id,c.cat_name FROM mingoods g RIGHT JOIN mincategory c ON g.cat_id = c.cat_id;
 
 
4、内连接查询 inner join ... on ...
 
语法：
 
select A.field1,A.field2,.., B.field3, B.field4 from <left table> A inner join <right table> B on <expression>
 
内连接查询，就是取左连接和右连接的交集，如果两边不能匹配条件，则都不取出。
 
SELECT g.goods_name,g.cat_id, c.* from mingoods g INNER JOIN mincategory c ON g.cat_id = c.cat_id;
 
 
5、全连接查询 full join ... on ...
 
语法：
 
select ... from <left table> full join <right table> on <expression>
 
全连接会将两个表的所有数据查询出来，不满足条件的为NULL。
 
全连接查询跟全相乘查询的区别在于，如果某个项不匹配，全相乘不会查出来，全连接会查出来，而连接的另一边则为NULL。
 
6、联合查询 union
 
语法：
 
select A.field1 as f1, A.field2 as f2 from <table1> A union (select B.field3 as f1, field4 as f2 from <table2> B)
 
union是求两个查询的并集。union合并的是结果集，不区分来自于哪一张表，所以可以合并多张表查询出来的数据。
 
 
6.1、将两张表的数据合并查询出来
 
SELECT id, content, user FROM comment UNION (SELECT id, msg AS content, user FROM feedback);
 
 
6.2、union查询，列名不一致时，以第一条sql语句的列名对齐
 
SELECT id, content, user FROM comment UNION (SELECT id, msg, user FROM feedback);
 
 
6.3、使用union查询会将重复的行过滤掉
 
SELECT content,user FROM comment UNION (SELECT msg, user FROM feedback);
 
 
6.4、使用union all查询所有，重复的行不会被过滤
 
SELECT content,user FROM comment UNION ALL (SELECT msg, user FROM feedback);
 
 
6.5、union查询，如果列数不相等，会报列数不相等错误
 
 
6.6、union 后的结果集还可以再做筛选
 
SELECT id,content,user FROM comment UNION ALL (SELECT id, msg, user FROM feedback) ORDER BY id DESC; 
 
 
      union查询时，order by放在内层sql中是不起作用的；因为union查出来的结果集再排序，内层的排序就没有意义了；因此，内层的order by排序，在执行期间，被mysql的代码分析器给优化掉了。
 
 (SELECT id,content,user FROM comment ORDER BY id DESC) UNION ALL (SELECT id, msg, user FROM feedback ORDER BY id DESC);
 
 
order by 如果和limit一起使用，就显得有意义了，就不会被优化掉。
 
( SELECT goods_name,cat_id,shop_price FROM goods WHERE cat_id = 3 ORDER BY shop_price DESC LIMIT 3 )
UNION
( SELECT goods_name,cat_id,shop_price FROM goods WHERE cat_id = 4 ORDER BY shop_price DESC LIMIT 2 );
 
 
 6.7、练习
 
 SELECT name, SUM(money) FROM ( ( SELECT * FROM A ) UNION ALL ( SELECT * FROM B ) ) tmp GROUP BY name;
 
 
 
连接查询总结：
 
1、在数据库中，一张表就是一个集合，每一行就是集合中的一个元素。连接查询即是作笛卡尔积，比如A表有1W条数据，B表有1W条数据，那么两表查询就有 1W X 1W = 100W 条数据　
 
2、如果在两张表里有相同字段，做联合查询的时候，要区别表名，否则会报错误(ambiguous 模糊不清)
 
3、全相乘效率低，全相乘会在内存中生成一个非常大的数据(临时表)，因为有很多不必要的数据。
 
 如果一张表有10000条数据，另一张表有10000条数据，两表全相乘就是100W条数据，是非常消耗内存的。
 
而且，全相乘不能好好的利用索引，因为全相乘生成一张临时表，临时表里是没有索引的，大大降低了查询效率。
 
4、左连接查询时，以左表为主表，会将左表所有数据查询出来；左表不动，右表根据条件去一条条匹配，如果没有满足条件的记录，则右边返回NULL。
 
右连接查询值，以右表为主表，会将右表所有数据查询出来，右表不动，左表则根据条件去匹配，如果左表没有满足条件的行，则左边返回NULL。　
 
左右连接是可以互换的：A left join B  ==  B right join A (都是以A为主表) 。
 
左右连接既然可以互换，出于移植兼容性方面的考虑，尽量使用左连接。
 
5、连接查询时，虽说也是读取一行行记录，然后判断是否满足条件，但是，连接查询使用了索引，条件列建立了索引的话，查询速度非常快，所以整体效率相比于全相乘要快得多，全相乘是没有使用索引的。
 
使用连接查询，查询速度快，消耗内存小，而且使用了索引。连接查询效率相比于全相乘的查询效率快了10+倍以上。
 
6、内连接查询，就是取左连接和右连接的交集，如果两边不能匹配条件，则都不取出。
 
7、MySql可以用union(联合查询)来查出左连接和右连接的并集。
 
union查询会过滤重复的行，union all 不会过滤重复的行。
 
union查询时，union之间的sql列数必须相等，列名以第一条sql的列为准；列类型可以不一样，但没太大意义。
 
union查询时，order by放在内层sql中是不起作用的；因为union查出来的结果集再排序，内层的排序就没有意义了；因此，内层的order by排序，在执行期间，被mysql的代码分析器给优化掉了。
 
 但是，order by 如果和limit一起使用，就显得有意义了，会影响最终结果集，就不会被优化掉。order by会根据最终是否会影响结果集而选择性的优化。
 
注：union和union all的区别，union会去掉重复的记录，在结果集合并后悔对新产生的结果集进行排序运算，效率稍低，union all直接合并结果集，如果确定没有重复记录，建议使用union all。
 
8、 LEFT JOIN 是 LEFT OUTER JOIN 的缩写，同理，RIGHT JOIN 是 RIGHT OUTER JOIN 的缩写；JOIN 是 INNER JOIN 的缩写。
 

关联查询
 
1、使用join关键字关联查询
 
（1）、内连接（inner join）
 
连接两张表，连接条件使用on关键字，内连接只会显示匹配的数据记录。
 
eg:查询学生姓名、科目、分数
 
select a.name 姓名,b.subject 科目,b.score 分数 from student a inner join score b on a.id = b.sid;
 
 
（2）、左连接（left join）
 
返回左表中所有记录以及右表中符合连接条件的所有记录。
 
eg: 使用左连接查询学生姓名、科目、分数
 
select a.name 姓名,b.subject 科目,b.score 分数 from student a left join score b on a.id = b.sid;
 
 
（3）、右连接（right join）
 
返回右表中所有记录以及左表中符合连接条件的所有记录。
 
eg:使用右连接查询学生姓名、科目、分数
 
select a.name 姓名,b.subject 科目,b.score 分数 from student a right join score b on a.id = b.sid;
 
 
注：内外连接区别：内连接只会显示匹配的数据记录，外连接例如左连接会把左边表中所有记录显示出来，即使在右边表中没有匹配记录也会显示左表的数据，右连接反之。
 
2、使用表和表之间相同id关联查询
 
这种关联方式和内连接一样，只会显示出匹配的数据
 
select a.name 姓名,b.subject 科目,b.score 分数 from student a,score b where a.id = b.sid;
 

数据库中我们做常用的就是SQL基本查询语言，甚至有些人认为数据库就是SQL，SQL就是数据库。虽然这种观点是错误的，但是也确实从一个方面体现了这种面向结果的查询语言的重要性。
SQL语言基本定义

 
 


基本类型
SQL表中支持很多固有类型，包括：
类型
含义
char(n)
存放固定长度的字符串，用户指定长度为n。如果没有使用n个长度则会在末尾添加空格。
varchar(n)
可变长度的字符串，用户指定最大长度n。char的改进版，大多数情况下我们最好使用varchar。
int
整数类型
smallint
小整数类型
numeric(p,d)
定点数，精度由用户指定。这个数有p位数字（包括一个符号位）d位在小数点右边。
real ,double precision
浮点数和双精度浮点数。
float(n)
精度至少位n位的浮点数
特殊关键字
SQL中用很多关键字来表达CRUD的操作（增删改查）。在这之外有很多特殊的关键字用来表示一些其他的含义，在总结SQL之前我们有必要进行一些了解。
类型
含义
示例
primary key
主键,后面括号中是作为主键的属性
primary key（student_id）
foreign key references
外键，括号中为外键，references后为外键的表
foreign key(course_id) references Course
not null
不为空，前面为属性的定义
name varchar(10) not null
SQL插入/删除/修改语句

 
 


SQL语法使用最多的就是查询，除了查找语句之外，其他的语句内容都很少。
类型
含义
create table
创建一张表
insert into…values
向表中插入一条信息
delete from
从表中删除一条信息
update…set…where
在where的位置，更新内容为set的值
drop table
删除表
alter table…add
向表中添加某个属性
alter table…drop
将表中的某个属性删除
create table
create table Student(
ID varchar(20) not null,
name varchar(10) not null, 
age int,
class varchar(50),
primary key (ID));
创建一张叫做Student的表，表中有四个属性，ID，姓名，年龄和班级，么个属性都有各自的类型。在这张表中主键是ID。
insert into…values
insert into Student(ID,name,class)
    values(10152510302,"Tom","class 1");
向表中添加一行信息，一个名叫Tom的学生的信息，因为age值不是not null，也就不是必须的，所以我们不添加age属性也没有问题。
delete from
delete form Student
    where name="Tom";
从表中删除所有名字叫做Tom的信息。如果delete from不写where查询条件表示清空这张表。
update…set…where
update Student
   set age=18
   where name="Tom";
将所有名字叫做Tom的信息的年龄设置为18。
drop table
drop table Student;
删除Student这张表。
alter table…add
alter table Student
   add sex varchar(5);
向表中添加性别属性，并且将表中以存放的信息的sex值设为null。所有通过这种方式添加的属性都不能被设置为not null类型。
alter table…drop
alter table Student
   drop class;
从表中将class这一列属性删除。
SQL查询语句

 
 


SQL最为常用的就是查询，我们使用数据库并从中查找出我们希望的内容。在这个过程中，我们可能要编写很复杂的语句。这里我们分类别详细的总结具体的查询情况。
单关系查询
单关系查询是指只一张表中的内容查询有关信息，不涉及其他的表，这是查询中最为基本的一种情况。我们通过这种情况来总结一些基本的SQL语句编写方法。下面先给出一些涉及到的关键字。
类型
含义
select
表示要查找出的表所含有的属性
from
表示要操作的表
where
判断条件，根据该判断条件选择信息
distinct
在select后加入关键字distinct表示将结果去重
all
在select后加入关键字all表示不去重（默认）
and
在where中使用and表示将判断条件连接起来
or
在where中使用or表示判断条件多选一
not
在where中使用not表示判断条件取反
在下面的查询语句中，我们仍旧使用Student这张表来进行操作。先回顾一下这张表的字段。
create table Student(
ID varchar(20) not null,
name varchar(10) not null, 
age int,
class varchar(50),
primary key (ID));
示例：
select name distinct
from Student
where age=18 and class="A";
在Student这张表中查询所有年龄是18岁，并且班级是A的学生的名字，并将结果去重。
多关系查询
多关系查询是指在多个表中通过一些操作查找出希望的信息。除去上面已有的关键字，我们还会使用到下面这些。
类型
含义
A，B
在from后面通过逗号连接多张表，表示将这些表进行笛卡儿积运算
natural join
将natural join关键字前后的两张表进行自然连接运算
A join B using(c)
将A和B通过c属性自然连接
 （补充：笛卡尔积
 
）
为了能够进行多关系查询，我们需要有除了Student的另外一张表。再建一张表，表示上数学课的所有学生的信息和成绩情况。（实际上这两张表建的都不好，不能满足基本的几个范式，但是为了方便起见用来举例）
create table Math(
   ID varchar(20) not null,
   name varchar(10) not null,
   sex varchar(5),
   score int,
   primary key(ID));
示例：
select score
form Student natural join Math
where class<>"B" and sex="men"
将Student表和Math表自然连接，所得的结果查询出不是B班的男生的成绩。
附加运算查询
我们已经总结了单关系和多关系运算的查询方法，但是只有这些
类型
含义
as
将as前的关系起一个别名，在此语句中，可以用别名来代指这个表
*
在select中通过: “表名.*” 来表示查找出这个表中所有的属性
order by
让查询结果中的信息按照给定的属性排序（默认升序，上小下大）
desc
在order by之后的属性后使用，表示采用降序排序
asc
在order by之后的属性后使用，表示采用升序排序（默认）
between
在where中使用between表示一个数在两个数值之间取值
not between
between的反义词，在两个数之外取值
union/union all
将两个SQL语句做并运算，并且自动去重，添加all表示不去重
intersect/intersect all
将两个SQL语句做交运算，并且自动去重，添加all表示不去重
except/except all
将两个SQL语句做差运算，并且自动去重，添加all表示不去重
is null
在where中使用is null表示这个值是空值
is not null
在where中使用is not null表示这个值不是空值
示例：
select S.*
from Student as S,Math as M
where S.ID = M.ID
将Student和Math两张表做笛卡儿积，结果中所有ID相同的信息，取出他们属于Student属性的部分作为结果。
select name
from Student natural join Math
where class="A" and sex="women"
order by score desc;
在Student和Math自然连接的结果中，找出A班的女生的姓名，并且按照成绩的降序把名字排列出来。
select name
from Math
where score between 60 and 90;
order by score asc;
在Math表中，找出成绩在60分到90分之间的学生姓名，并且将姓名按照成绩的升序排列出来。
(select name
from Student natural join Math
where class="A" and sex="women"
order by score desc)
union
(select name
from Math
where score between 60 and 90;
order by score);
将上面两个查出来的结果做并集，并且去重。
select name
from Student 
where age is null;
在Student表中记录的年龄值未填写（为空）的所有人的姓名查出来。
聚集函数运算查询
已经总结了SQL语句的很多关键字，现在我们可任意的进行排序、查找。但是如果我们要获得一些与数据相关的统计信息，但是这些信息在数据库中没有，那么我们要使用SQL中的聚集函数来进行操作。
类型
含义
avg
平均值
min
最小值
max
最大值
sum
总和
count
计数
distinct
表示将distinct后的属性去重
group by
将在group by上取值相同的信息分在一个组里
having
对group by产生的分组进行筛选，可以使用聚集函数
示例：
select class,avg(score) as avg_score
from Student natural join Math
group by class
having avg(score) < 60;（这里应该是avg(score) >60吧）
在Student与Math表自然连接的结果中按照班级分组，并且去除那些班级的平均成绩没到60的班级，剩下的班级和该班成绩的平均数（该班成绩的平均数这个属性被重命名为avg_score）作为一张新表被输出出来
 
第二篇：
关于SQL中的having用法（这篇很清晰的介绍了通过having和不通过having用法的区别）
https://www.cnblogs.com/lao-tang/p/6398577.html
现在 Student表有如下数据


现需求如下：查找每个老师的学生的平均年龄且平均年龄大于12
不使用 HAVING
1SELECT*FROM (SELECT TeacherID, AVG(Age) AS AGE FROM Student
2   GROUPBY TeacherID) T WHERE T.AGE>12
使用HAVING
1   SELECT TeacherID, AVG(Age) AS AGE FROM Student
2   GROUPBY TeacherID
3   HAVING AVG(Age) >12
结果如下：
 
HAVING:给分组设置条件
SQL语句中设定集合函数的查询条件时使用Having从句而不是where从句。通常情况下，having从句是被放置在SQL命令的结尾处。
 
第三篇
Sql中的exists，not exists的用法
https://www.cnblogs.com/mytechblog/articles/2105785.html
sql中exists,notexists的用法
exists : 强调的是是否返回结果集，不要求知道返回什么,比如：
  select name from student where sex = 'm' and mark exists(select1 from grade where ...) ,只要
exists引导的子句有结果集返回，那么exists这个条件就算成立了,大家注意返回的字段始终为1，如果改成“select 2from grade where ...”，那么返回的字段就是2，这个数字没有意义。所以exists子句不在乎返回什么，而是在乎是不是有结果集返回。

而 exists 与 in 最大的区别在于in引导的子句只能返回一个字段，比如：
  select name from student where sex = 'm' and mark in (select1,2,3 from grade where ...)  
，in子句返回了三个字段，这是不正确的，exists子句是允许的，但in只允许有一个字段返回，在1，2，3中随便去了两个字段即可。

而not exists 和not in 分别是exists 和 in 的对立面。
exists （sql 返回结果集为真）  
not exists (sql 不返回结果集为真）
下面详细描述not exists的过程：
如下：
表A
ID NAME  
1   A1
2   A2
3   A3

表B
ID AID NAME
1   1     B1
2   2     B2  
3   2     B3

表A和表B是１对多的关系 A.ID => B.AID

SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE A.ID=B.AID)
执行结果为
1 A1
2 A2
原因可以按照如下分析
SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=１)
--->SELECT * FROM B WHERE B.AID=１有值返回真所以有数据

SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=2)
--->SELECT * FROM B WHERE B.AID=２有值返回真所以有数据

SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=3)
--->SELECT * FROM B WHERE B.AID=３无值返回真所以没有数据

NOT EXISTS 就是反过来
SELECT ID,NAME FROM A WHERENOT EXIST(SELECT * FROM B WHERE A.ID=B.AID)
执行结果为
3 A3
===========================================================================
EXISTS = IN,意思相同不过语法上有点点区别，好像使用IN效率要差点，应该是不会执行索引的原因
SELECT ID,NAME FROM A WHEREID IN (SELECT AID FROM B)

NOT EXISTS = NOT IN ,意思相同不过语法上有点点区别
SELECT ID,NAME FROM A WHEREIDNOT IN (SELECT AID FROM B)
 有时候我们会遇到要选出某一列不重复,某一列作为选择条件,其他列正常输出的情况.
如下面的表table:
Id  Name  Class Count  Date
 1   苹果   水果   10     2011-7-1
 1   桔子    水果    20     2011-7-2
 1   香蕉   水果   15     2011-7-3
 2   白菜    蔬菜    12    2011-7-1
 2   青菜   蔬菜    19    2011-7-2
如果想要得到下面的结果:(Id唯一,Date选最近的一次)
1   香蕉   水果   15     2011-7-3
2   青菜   蔬菜    19    2011-7-2
正确的SQL语句是:
SELECT Id, Name, Class, Count, Date
FROM table t
WHERE (NOT EXISTS
          (SELECT Id, Name,Class, Count, Date FROM table 
         WHERE Id = t.Id ANDDate > t.Date))
如果用distinct,得不到这个结果, 因为distinct是作用与所有列的
SELECT DISTINCT Id, Name, Class, Count, Date FROM table
结果是表table的所有不同列都显示出来,如下所示:
 1   苹果    水果   10     2011-7-1
 1   桔子    水果    20     2011-7-2
 1   香蕉   水果   15     2011-7-3
 2   白菜    蔬菜    12    2011-7-1
 2   青菜   蔬菜    19    2011-7-2
如果用Group by也得不到需要的结果,因为Groupby 要和聚合函数共同使用,所以对于Name,Class和Count列要么使用Group by,要么使用聚合函数. 如果写成
SELECT Id, Name, Class, Count, MAX(Date) 
FROM table
GROUP BY Id, Name, Class, Count
得到的结果是
 1   苹果    水果   10    2011-7-1
 1   桔子    水果    20     2011-7-2
 1   香蕉   水果   15     2011-7-3
 2   白菜    蔬菜    12    2011-7-1
 2   青菜   蔬菜    19    2011-7-2
如果写成
SELECT Id, MAX(Name), MAX(Class), MAX(Count), MAX(Date) 
FROM table 
GROUP BY Id
得到的结果是:
 1   香蕉   水果    20    2011-7-3
 2   青菜   蔬菜    19    2011-7-2
如果用in有时候也得不到结果,（有的时候可以得到，如果Date都不相同（没有重复数据），或者是下面得到的Max（Date）只有一个值）
SELECT DISTINCT Id, Name, Class, Count, Date FROM table
WHERE (Date IN
          (SELECT MAX(Date)
         FROM table
         GROUP BY Id))
得到的结果是：（因为MAX(Date)有两个值2011-7-2，2011-7-3）
 1   桔子    水果    20     2011-7-2
 1   香蕉   水果   15     2011-7-3
 2   青菜   蔬菜    19    2011-7-2
注意in只允许有一个字段返回
有一种方法可以实现：
SELECT Id, Name, Class, COUNT, Date
FROM table1 t
WHERE (Date =
          (SELECT MAX(Date)
         FROM table1
         WHERE Id = t .Id))
 
第四篇
SQL子查询Exists和Not Exists的区别（这篇讲的很精彩）
https://blog.csdn.net/qq_27571221/article/details/53090467
MySQL EXISTS 和 NOT EXISTS 子查询语法如下：
·        SELECT … FROM table WHERE EXISTS (subquery)
该语法可以理解为：将主查询的数据，放到子查询中做条件验证，根据验证结果（TRUE 或 FALSE）来决定主查询的数据结果是否得以保留。
MySQL EXISTS 子查询实例
下面以实际的例子来理解 EXISTS 子查询。下面是原始的数据表：
article 文章表:
aid
title
content
uid
1
文章1
文章1正文内容…
1
2
文章2
文章2正文内容…
1
3
文章3
文章3正文内容…
2
4
文章4
文章4正文内容…
4
user 用户表:
aid
title
content
1
admin
admin@5idev.com
2
小明
xiao@163.com
3
Jack
jack@gmail.com
我们要查出 article 表中的数据，但要求 uid 必须在 user 表中存在。SQL 语句如下：
·        SELECT * FROM article WHERE EXISTS (SELECT * FROM user WHEREarticle.uid = user.uid)
返回查询结果如下：
aid
title
content
uid
1
文章1
文章1正文内容…
1
2
文章2
文章2正文内容…
1
3
文章3
文章3正文内容…
2
从语句执行结果可以看出，article 表中第 4 条记录没有被保留，原因就是该条记录的数据在子查询中返回的结果是 FALSE 。 
当上面的 SQL 使用 NOT EXISTS 时，查询的结果就是 article 表中 uid 不存在于 user 表中的数据记录。
下面来三张表的实例
我们先介绍下使用的3个数据表：
student数据表：
sno 学号
sname
ssex
sage
20161181
Altair
男
20
20161182
Desmond
男
18
20161183
Ezio
男
22
20161184
Christina
女
19
course数据表：
cno 课程编号
cname 课程名
1
C语言
2
数据结构
3
信号与系统
4
模拟电子技术
5
高数
sc数据表：
sno 学号
cno 课程编号
grade 成绩
20161181
1
99
20161182
2
98
20161181
2
97
20161181
3
95
20161184
3
92
20161181
4
90
20161181
5
88
20161183
5
58
EXISTS
EXISTS代表存在量词∃。带有EXISTS谓词的子查询不返回任何数据，只产生逻辑真值“true”或者逻辑假值“false”。
一个例子1.1：
要求：查询选修了课程”信号与系统“的同学
SELECT s.Sname FROM student s
WHERE EXISTS  
(SELECT * FROM sc, course c WHERE sc.sno = s.sno AND sc.cno = c.cno AND c.cname = '信号与系统')
使用存在量词EXISTS后，若内层查询结果为非空，则外层的WHERE子句返回值为真，否则返回值为假。
在本例中，首先分析最内层的语句：
SELECT * FROM sc, course c WHERE sc.sno = s.sno AND sc.cno = c.cno AND c.cname = '信号与系统'
本例中的子查询的查询条件依赖于外层父查询的某个属性值（本例中的是Student的Sno值），这个相关子查询的处理过程是：
首先取外层查询中（student）表的第一个元组，根据它与内层查询相关的属性值（Sno值）处理内层查询，若外层的WHERE返回为真，则取外层查询中该元组的Sname放入结果表；
然后再取（student）表的下一组，重复这一过程，直至外层（Student）表全部检查完毕。
查询结果表：
Sname
Altair
Christina
NOT EXISTS
与EXISTS谓词相对的是NOT EXISTS谓词。使用存在量词NOT EXISTS后，若对应查询结果为空，则外层的WHERE子语句返回值为真值，否则返回假值。
例子2.1： 
要求：查询没有选修课程”信号与系统“的同学
SELECT s.Sname FROM student s
WHERE NOT EXISTS  
(SELECT * FROM sc, course c WHERE sc.sno = s.sno AND sc.cno = c.cno AND c.cname = '信号与系统')
使用NOT EXISTS之后，若内层查询结果为非空，则对应的NOT EXISTS不成立，所以对应的WHERE语句也不成立。
在例子1.1中李勇同学对应的记录符合内层的select语句的，所以返回该记录数据，但是对应的NOT EXISTS不成立，WHERE语句也不成立，表示这不是我们要查询的数据。
查询结果表：
Sname
Desmond
Ezio
例子2.2（这是一个用NOT EXISTS表示全称量词的例子）：
要求：查询选修了全部课程的学生姓名。
SQL语句：
SELECT Sname  
FROM Student   
WHERE NOT EXISTS  
(SELECT * FROM Course WHERE NOT EXISTS  
     (SELECT * FROM SC WHERE Sno=Student.Sno AND Cno=Course.Cno)  
);  
这个算是一个比较复杂的sql语句了，两个EXISTS和三个WHERE。
这个sql语句可以分为3层，最外层语句，最内层语句，中间层语句。
我们很关心最外层语句，因为结果表中的数据都是最外层的查询的表中的数据，我们更关心最内层的数据，因为最内层的数据包含了全部的判断语句，决定了student表中的那一条记录是我们查询的记录。
我们由内而外进行分析：
最外层的student表中的第一条记录是Altair同学对应的记录，然后中间层的course表的第一条记录是数据库对应的记录，然后对该数据进行判断（最内层的WHERE语句），结果返回真，则内层的NOT EXISTS为假， 
然后继续对course表中的下一条记录进行判断，返现NOT EXISTS的值也为假，直到遍历完course表中的所有的数据，内层的NOT EXISTS的值一直都是假，所以中间层的WHERE语句的值也一直都是假。 
对应student的Altair记录，course表中的所有的记录对应的中间层的返回值为假，所以最外层的NOT EXISTS对应的值为真，最外层的WHERE的值也为真，则Altair对应的记录符合查询条件，装入结果表中。 
然后继续对student表中的下一条记录进行判断，直达student表中的所有数据都遍历完毕。
下面是我自己对这段sql的解读：
先取一条student记录，进入中层，再取一条course的记录，进入内层，此时student的记录和course的记录，作为内层判断的条件，比如此时我取的第一条记录是Altair，那么我里面的Sql就可以写成
SELECT * FROM Course WHERE NOT EXISTS  
     (SELECT * FROM SC WHERE Sno = '20161181' AND Cno=Course.Cno)  
)
此处 sno 20161181即Altair的学号，这条sql的意思是选出没有被Altair选择的课程，如果不存在，则返回false，再跟最外层的NOT EXISTS关联，负负得正。每一条循环的意思就是指，筛选出的每一个学生都不存在没有被他选取的那门课，即选了所有课。
最终查询结果：
Sname
Altair
 
 
第五篇：
SQL中的Except，Intersect用法
https://www.cnblogs.com/dyufei/archive/2009/11/11/2573976.html
ＳＱＬ中　EXCEPT、INTERSECT用法
EXCEPT 返回两个结果集的差（即从左查询中返回右查询没有找到的所有非重复值）。
INTERSECT 返回两个结果集的交集（即两个查询都返回的所有非重复值）。
ＵＮＩＯＮ返回两个结果集的并集。
语法：
{ （<ＳＱＬ－查询语句１>）} 
{ EXCEPT | INTERSECT } 
{ （<ＳＱＬ－查询语句２> ）}
限制条件
·        （１）所有查询中的列数和列的顺序必须相同。
·        （２）比较的两个查询结果集中的列数据类型可以不同但必须兼容。
·        （３）比较的两个查询结果集中不能包含不可比较的数据类型（xml、text、ntext、image 或非二进制CLR 用户定义类型）的列。
·        （４）返回的结果集的列名与操作数左侧的查询返回的列名相同。ORDERBY 子句中的列名或别名必须引用左侧查询返回的列名。
·        （５）不能与COMPUTE 和 COMPUTE BY子句一起使用。
·        （６）通过比较行来确定非重复值时，两个NULL 值被视为相等。（EXCEPT 或 INTERSECT 返回的结果集中的任何列的为空性与操作数左侧的查询返回的对应列的为空性相同。）
与表达式中的其他运算符一起使用时的执行顺序
１、括号中的表达式
２、INTERSECT 操作数
３、基于在表达式中的位置从左到右求值的 EXCEPT 和 UNION
如果 EXCEPT 或 INTERSECT 用于比较两个以上的查询集，则数据类型转换是通过一次比较两个查询来确定的，并遵循前面提到的表达式求值规则。
举例：
ｔａｂｌｅＡｔａｂｌｅＢ
ＮＵＬＬ
ＮＵＬＬ
ＮＵＬＬ
２
１
３
１
４
２
５
３
５
４
 
５
 
Ａ：（SELECT * FROM TableA） EXCEPT （SELECT * FROM TableB）
结果：　１
(1 row(s) affected)
Ｂ：　SELECT * FROM TableA INTERSECT SELECT * FROM TableB
结果：２
　　　３
　　　４
　　　５
    (４ row(s) affected)
 部分转载于：https://blog.csdn.net/quinnnorris/article/details/71056445
SQL关键字的执行顺序：
　　1. FROM：对FROM子句中前两个表执行笛卡尔积生成虚拟表vt1
　　2. ON: 对vt1表应用ON筛选器只有满足 join_condition 为真的行才被插入vt2
　　3. OUTER(join)：如果指定了 OUTER JOIN， 保留表(preserved table)中未找到的行，将行作为外部行添加到vt2，生成t3，如果from包含两个以上表，则对上一个联结生成的结果表和下一个表重复执行步骤和步骤直接结束。
　　4. WHERE：对vt3应用 WHERE 筛选器只有使 where_condition 为true的行才被插入vt4
　　5. GROUP BY：按GROUP BY子句中的列，对vt4中的行分组生成vt5
　　6. CUBE|ROLLUP：把超组(supergroups)插入vt6，生成vt6
　　7. HAVING：对vt6应用HAVING筛选器只有使 having_condition 为true的组才插入vt7
　　8. SELECT：处理select列表产生vt8
　　9. DISTINCT：将重复的行从vt8中去除产生vt9
　　10. ORDER BY：将vt9的行按order by子句中的列列表排序生成一个游标vc10

　　11. TOP：从vc10的开始处选择指定数量或比例的行生成vt11 并返回调用者
转载于：https://blog.csdn.net/cqnuztq/article/details/8683656

第一单元、SQL关键字,聚合函数 
 SQL关键字
 Navicat是一个本地的客户端软件,用来操作mysql数据库
 前提:
 库、表名、字段名如果为关键字需要加`` desc
 字段名===列名
 1.1、增加
 增加一条数据
 insert into 表名(字段名,字段名,字段名) values(‘值’,’值’,’值’)
 增加多条数据
 insert into 表名(字段名,字段名,字段名) values(‘值’,’值’,’值’),(‘值’,’值’,’值’)
 1.2、删除
 语法
 delete from 表名 where 条件;
 注意:where条件
 1.3、修改
 语法结构
 Update 表名 set 字段名=’新值’,字段名=’新值’ where 条件
 注意:where条件
 1.4、查询
 语法结构
 select 字段列表 from 表名 where 条件 order by 排序字段 升序/降序 limit 开始位置，条数
 字段列表
 字段1,字段2,字段3,字段4
 查询所有字段时可以使用*代替
 例如:查询user表,性别,grade成绩的数据信息
 select sex,grade from user;显示的数据只有性别成绩数据
 Where
 运算符
 
 
 
< >= <= !=
 例如:查询user表中年龄>17岁的SQL
 Select age from user where age>17;
 and 并且
 例如:查询user表中姓名是小明并且年龄!=16
 Select age from user where uname=‘小明’ and age!=16;
 or或者
 特殊情况 一个字段等于两个值 一定用or 例如年龄为17和25
 例如:查询user表中姓名是小明或者性别是男的
 Select age from user where uname=‘小明’ or sex=‘男’;
 Between and 在**之间
 语法: 字段 between 值 and 值
 等同于 字段>=值 and 字段<=值
 例如:查询年龄为18-22的信息
 select * from user where age between 18 and 22
 select * from user where age>=18 and age<=22
 
 
模糊查询 like
 _ 匹配任意一位 %匹配多位 %通配符
 语法: 字段 like ‘%值%’
 例如:查询user表用户名包含小的信息
 Select * from user where uname like ‘%小%’;
 批量操作 in
 语法: 字段 in （值1,值2,值3） 等同于 字段=值1 or字段=值2 or 字段=值3
 例如:查询user表id是1,2,3的信息
 select * from user where id in(1,2,3);
 例如:删除user表id是1,2,3的信息
 delete from user where id in(1,2,3);
 order by排序
 语法: order by 字段 升序asc/降序desc
 升序 asc 默认(由小到大)
 降序 desc(由大到小)
 例如:user表根据id降序排序(显示的时候id是按照由大到小)
 Select * from user order by id desc;
 多列排序
 需求是:查询user表, 按照年龄倒序,成绩倒序排序
 注意:①如果第一列排序有相等的内容,则按照第二个排序条件进行排序 ②如果第一列排序中没有相等的内容,则第一列优先级大于第二列的优先级,按照第一列排序规则显示效果
 
#排序 order by asc 升序 desc降序
 select * from user order by age desc,grade asc;
 注意:表名后面一定不要加where
 limit
 语法:limit 开始位置,条数,开始位置可省略,如果省略默认从0开始
 例如:查询user表中成绩>=10的信息限制记录条数3;
 select * from user where grade>=10 limit 3;
 二、聚合函数
 语法 聚合函数(字段)
 count条数
 例如:查询用户表中总条数 并且给查询到总条数起别名叫做num
 select count(id) as num from user;
 sum和
 例如:求赵四同学的成绩总和
 select sum(grade) as grade_sum from user where username=‘赵四’;
 min最小值
 例如:求赵四同学的成绩最小值
 select min(grade) as grade_min from user where username=‘赵四’;
 max最大值
 例如:求赵四同学的成绩最大值
 select max(grade) as grade_max from user where username=‘赵四’;
 avg平均值
 例如:求赵四同学的成绩的平均值
 select avg(grade) as grade_avg from user where username=‘赵四’;
 三、表关系,两表SQL,关联查询
 表关系
 (1)一对一
 (2)一对多
 需要将班级表(一表的id)放到学生表中,作为关联字段
 例如:一个班级下可以有多个学生
 一个学生只属于一个班级
 所以班级 学生为1对多关系
 1对多关系 需要建立两张表
 学生表student(多) 班级表class(一)
  
 多的表student中放一个 1的表的id
 如果查询结果或条件涉及到两张表的数据需要关联查询
 (3)多对多
 例如: 一个讲师可以带多门课程
 一个课程也可以被多个讲师带
 所以讲师、课程为1对多关系
 两表联查SQL
 select * from 表1 inner join 表2 on 表1.字段=表2.字段;
 Inner join表示连接 inner可以省略
 On表示筛选
 学生表和班级表为例 sql语句
 Slect * from class join student on class.cid=student.cid;
 3、关联查询(1对多表关系查询)
 (1)关联查询原理
 交叉连接 – 笛卡尔乘积
 sql语句:
 
 查询结果:
 
 (2)内连接 [inner] join
 sql语句加上筛选 on:
 
 sql语句加上筛选on的查询结果:
 
 (3)外连接
 左外连接 left join
 以left join左边的表为主表，主表信息全部查询，
 去从表(右边的表)中匹配，查询到 显示数据，查询不到显示null。
 sql语句:
 
 查询结果:
 
 右外连接 right join
 以right join右边的表为主表，主表信息全部查询，
 去从表(左边的表)中匹配，查询到 显示数据，查询不到显示null
 四、会话控制
 2.1、cookie的使用
 创建cookie
 setcookie(‘名’,’值’) //会话(临时cookie)cookie
 setcookie(‘名’,’值’,过期时间);//持久cookie
 过期时间要从当前时间+你想设置的秒数
 取出cookie
 $_COOKIE[‘名’];
 销毁cookie
 setcookie(‘名’,’’,time()-秒数)
 只要是从当前时间time()-任意秒数 表示当前时间之前，已经过去
 2.2、Session的使用
 开启session
 session_start()
 或 php.ini中 session.auto_start = 0把0改为1
 注意:修改配置文件session全部开启了
 (1)设置session
 $_SESSION[‘名’]=值;
 (2)取session中的值
 ${}_{S}ESSION[‘名字’];(3)删除sessionunset($_SESSION[‘名’])
 
后续会讲session,cookie的使用