同学们，以下是今日任务。今日重点是多表的内外连接查询以及子查询，要求每位同学练习课堂多表相关练习，然后以口语化的方式在评论区提交你的每日总结，谈谈你对今日重点知识的理解!

• 多表设计的分析与创建
• 掌握多表查询之内外连接查询以及子查询的使用
• 阐述什么是事务以及事务的四种隔离级别演示
  
  

吴利君
    今天学习的了数据库的进阶知识数据库的多表操作以及事务的管理，首先，我们学习的是MySQL它是关系型数据库，不像MongoDB和Redis这样的分布式数据库，它具有很强的关系，因此，在MySQL数据库之中，各个表之间都是通过主外键连接起来形成主从表的各种关系，而我们可以通过这种主外键进行多表连接查询。
数据库的创建和删除直接通过可视化软件就可以直接完成，但是表的数据是以后很多都会用到的，因此学会表的查询很重要。
     这里我们表的查询其实不难，格式就是select * from * where * group by * having * order by* 格式就是这样，这是单表，如果多表，我们可以使用where然后进行表格id连接，a.id=b.id这种方式，这种可以有多个，只需要再加一个等式就行。
    然后是查询的内联查询和外联查询，这种查询很重要，格式也相对固定，记住就好，最后是子查询，这个很重要，我们可以在查询语句里面插入多个查询语句，这样可以极大提高SQL语句的效率，而且我们可以通过in exists等关键字进行更加灵活的设计，极大的提高代码的简洁以及执行效率。
    最后讲的是事务的管理，这几种情况是数据库操作的常见错误，今天讲的知识皮毛，以后还会进行深入讲解。我记得hibernate里面和mybatis以及spring里面都有事务相关的管理，有点难，不容易理解！

常小天
今天学习了MySQL多表和事务的内容，重点在多表，事务只是简单了解一些入门知识，知道一些概念而已。多表部分的重点内容有外键和多表联合查询两部分。外键即为与外部表联系的键，它是伴随一对多的关系而产生的。一对多关系就是一个表中的多条表记录可以通过一个字段（外键）指向另一个表中的同一条表记录。举个例子就是一个班级里有多个学生，这多个学生就是“学生”这个表中的多条表记录，他们都属于一个班级，也就是通过班号指向了某一个唯一的班级，这个班级就是“班级”这个表中的一条具体的表记录。表一（班级）中存在一个具有标识功能（不重复）的字段（班号），表二（学生）想要将表一（班级）的表记录（具体的班级）作为一种属性赋给自己的表记录（一个个具体的学生），就要把表一的那个字段（班号）拿来给自己的表记录（具体的学生）使用，这个拿的动作就是建立外键，将表二（学生）里的那个借来的字段（班号）与表一（班级）里的具有标识功能的字段（班号）联系起来，让电脑知道表二里的班号就是指代表一里的班号。第二部分多表联合查询。这一部分内容要记忆并理解各种查询方法的格式和意义范畴。这其中的重点在连接查询的内连接和外连接。内连接中的显示、隐式连接在范畴上没有差别。记住格式，再记住他们的范畴是查询表一和表二都有内容的那部分表记录，就可以了。外连接分左外连接和右外连接，这两者在格式上只差一个单词，容易记忆，而他们范畴上的区别需要理解清楚。首先两个表连接的时候在左边的为主表。左连接是将关键字前的表（记为表一）拼在另一个表（记为表二）的左边，所以表一为主表，那么查询的结果是将主表，也就是表一的全部内容显示出来，即使表二中没有与表一的表记录相对应的记录。与之相反，右连接是将关键字前的表（还是记为表一）拼在另一个表（记为表二）的右边，表二在左，所以表二为主表，那么查询的结果是将主表（表二）的全部内容显示出来，即使表一中没有与表二的表记录相对应的记录。当然查询结果是将两个表的字段拼起来全部显示这样一种格式来显示的。这些基础理解了之后，再下来就是多做练习，最终达到能将这些内容融会贯通的使用。

曾耀峰  
  今天学习SQL多表操作。多对多关系的表的建立，可以通过mysql数据库可视化管理工具来进行。在建立多对多关系的表，要先建立一个中间表，把两个表之间的主键放到中间表中，对于中间表，分别设置两个外键关联到这两个表之中。建议先建立多表之间的关系，再往表里面添加数据。
   今天的难点是多表查询，涉及到的重点知识有内连接查询，外连接（左外连接，右外连接）查询，和子查询三个。
   通过多表查询的练习后，个人觉得可以把多个表之间的查询看成一个整体表。因为表与表之间是有关联的，查询几个表的数据同样会得出一张大表。把N个表看成一个整体表，在逻辑上的理解会比较容易。
   另外通过子查询可以把一个复杂的查询转换为多个简单的小查询再进行拼接。


一、多表联合查询:
1.交叉查询:
  
  1).交叉查询是求多个表之间的笛卡儿积的所有情况，比如班级表classes有4个记录(数据)，学生表student有9个记录，那么使用交叉查询所得到的就是36个记录。以表student为主表遍历classes表。像java中的二维数组遍历一样。
  交叉查询应用少，在求所有情况才使用。理解即可。

  2).格式:
  (1).select * from classes cross join student;
  (2).select * from classes join student;
  (3).select * from student,classes;

  其中corss join可以省略。


2.内连接(重点) inner join（inner 可以省略）
   把两个表看作两个集合，内连接就是求两个表交集的那部分。分为两部分:

   -显示内连接:在SQL中显示的调用inner join关键字
      语法: select * from 表1 inner join 表2 on 关联条件

      举例:
      
      select * from classes c inner join student s on c.cid = s.cno;

      查找出c中cid的值等于s中cno的值的所有情况:

      比如:cid = 1时，con = 1 有3个记录
           cid = 2时，con = 2 有3个记录
           cid = 3时，con  =3 有2个记录

   -隐式内连接:在SQL中没有调用inner join关键字

      语法:select * from表1，表2 where 关联条件
   
      
3.外连接(重点) outter join(outer 可以省略)
   
    - 左外连接:LEFT JOIN
        语法:select * from 表1 left outer join 表2 on 关联条件
   
        SELECT * from  classes c LEFT JOIN  student  s on c.cid = s.cno;

        以左边的classes为主表，得到classes的所有数据。然后得到 c 与 s交集部分的数据;
   
   - 右外连接:RIGHT JOIN
        
        select * from classes c RIGHT JOIN student s on c .cid = s.cno;
  
        以右边的student为主表，先得到student的所有结果，然后再得到c 与s交集部分的数据

        
        

4.子查询

    一个查询语句条件需要依赖另一个查询语句的结果。

select ename,job from emp y,emp l where y.mgr = l.empo;

多表查询的练习:

1.查询班级名称，和班级总人数

分析:

    -1.查班级名称,班级总人数 :select c.cname,count(*) from student s,classes c
    -2.两张表的关联条件: where c.cid = s.cno;
    -3.因为student表里面的记录了学生的班级编号，是个重复的字段。因此要对s.cno分组: group by s.con;
    -4.合并 select c.cname，count(*) from student s,classes c where c.cid = s.cno group by s.con;

2.查询学生的姓名和学生所选的总课程平均成绩。

分析:
    -1.查询学生姓名，所学总课程平均成绩:select s.sname,VAG(sc.score) from  student s, stu_cour sc;

    -2.在stu_cour表里求总课程平均成绩:首先 每个学生编号sno是重复的，对这个编号分组，就能得出每个学生所选的课程和成绩:group by sc.sno;

    -3.两张表的关联条件: where s.sid = sc.sno;
     
    -4.合并:select s.sname,VAG(sc.score) from  student s, stu_cour sc where s.sid = sc.sno  group by sc.sno;


3.查询学生的姓名和学生的选课总数，显示选课超过2门学生姓名.

分析:当遇到"数目","总数","数":肯定是求数量，求数量就要用到分组统计count(*) 和group by。选课数量超过2门，只能用having关键字来写。

   select s.sname,count(*) from from student s,stu_cour sc where s.sid = sc.sno group by sc.cno having count(*)>2;

4.查询平均成绩大于80分的学生的总数。

分析:因为求平均分和总数，这里涉及到两个聚合函数。把它拆分成题1"求平均成绩大于80分的学生"，题2"求学生的总数"这两个问题

题1:"求平均成绩大于80分的学生":利用聚合函数 和分组:对stu_cour表中的学生学号sno分组，因为一个学生有一个学生有多个科目和成绩

select sc.sno from stu_cour sc GROUP BY sc.sno HAVING AVG(sc.socre)>80

题2:"学生的总数":select count(*) from student s where s.id =？;

用 in来连接:
select count(*) from student s where s.id in (select sc.sno from stu_cour sc GROUP BY sc.sno HAVING AVG(sc.socre)>80);
   
5.查询学生和平均成绩，但是平均成绩大于01班的任何一个学生的平均成绩。

-题目1:"01班的每个学生的平均成绩":
  学生的平均成绩
  select avg(sc.score) from stu_cour sc group by sc.son;

  01班的学生:
  select s.sid from student s,classes c2 where s.cno  = c2.cid And c2.cname = '01班';

  拼接:因为是01班的学生 所以通过sid in()来拼接
  select avg(sc.score) from stu_cour sc class group by sc.son where s.sid in (select s.sid from student s,classes c2 where s.cno  = c2.cid And c2.cname = '01班');

  大于任何一个学生，应该是最大值了:all()
  查询学生和平均成绩:
  select s.sname,avg(sc.socre) from student s,stu_cour sc group by sc.sno having avg(sc.socre)>any

张裕
                                MySQl多表
多表中有个外键约束:用来保证数据的完整性       
添加外键约束
        alter table 表名 add foreign key(列名) references 表名(列名);
设置外键不允许为空
        alter table 表名 modify 列名 类型 not null;

多表中有三种关系         一对多(教室和学生) 在教室表中创建外键 指向学生表
                多对多(课程和学生) 需要创建中间表 表中有两个字段作为外键指向两张表的主键
                一对一(公司和地址)         唯一外键对应方式:假设是一个一对多关系,在多的一方创建外键指向单个的主键,将外键设置成唯一(unique)
                                主键对应方式:将两个表的主键建立对应关系


                                        多表查询
分类
连接查询
        交叉连接: cross join 查询到的是两个表的笛卡尔积(得到两个表的乘积)
                        select * from 表一 cross join 表二;(或者将cross join替换成 , 号)

        !内连接:inner join(可省略)
                显示内连接:在SQL中显示的调用了inner join关键字
                        select * from 表一 inner join 表二 on 关联条件;
                隐式内连接:没有调用inner join 关键字
                        select * from 表一,表二 where 关联条件;

        !外连接:outer join(可省略)
                左外连接
                        select * from 表一 left outer join 表二 on关联条件;
                右外连接
                        select * from 表一 right outer join 表二 on关联条件;

内外连接的区别: 内连接查询的是两张表的公共部分 左外连接查的是左边表的全部加两张表的交集和右外连接相同

子查询
        一个查询语句条件需要依赖另一个查询语句的结果(语句嵌套)
        in(范围查找)
                select * from 表一 where 列名 in(select....条件);       
        exists(是否存在)
                判断记录是否存在,存在执行前面的SQL语句
        any(任意一个)
                判断条件是否> < 任意一个 执行SQL语句(排除最大最小?)
        all(比较所有 max min)
                判断是否> <所有 执行SQL语句(获得最大最小?)
       



                                        事务
事务:指的是逻辑上的一组操作,组成这组操作的各个逻辑单元,要么全部成功,要么全部失败.

开启事务
        start transaction
提交事务
        commit
回滚事务
        rollback

事务的隔离级别
由低到高        read uncommitted
        read committed
        repeatable read
        serializable
                       

游荣辉
单表约束
        主键约束        唯一约束        非空约束
多表约束
        外键约束(为了提高安全性)
多表有三种表关系       
        1.一对多: 如创建外键约束: 在多的一方创建外键指向一的一方的主键
        2.多对多: 如创建外键约束: 需要创建中间表，中间表中至少两个字段，分别作为外键指向多对多双方的主键
        3.一对一: 如创建外键约束: 唯一外键对应
                                        假设是一对多，在多的一方创建外键指向一的一方的主键，将外键设置为unique。
                                    主键对应
                                        将两个表的主键建立对应关系即可。
如何查询多表呢?
        查询多表有四种方式
                交叉连接:使用cross join关键字 (可以不写cross)
                        1.select * from 表名1 cross join 表名2;
                         不使用cross join关键字(把cross join改成逗号)
                        2.select * from classes,student;
                内连接:使用inner join和on 关键字(又叫显示内连接,可以不写inner)
                        1.select * from 表名1 inner join 表名2 on 连接条件
                        不使用inner join和on 关键字(又叫隐世内连接)
                        2.select * from 表名1 , 表名2 where 连接条件
                外连接:使用left outer join关键字(叫做左外链接,可以不写outer)
                        1.select * from 表名1 left outer join 表名2 on 连接条件
                        使用rigth outer join关键字(叫做右外连接,可以不写outer)
                        2.select * from 表名1 rigth outer join 表名2 on 连接条件
                子查询:就是在sql语句中嵌套sql语句(这是最简单的子查询语句还有带 in  any    exists   all)

李思贤:今天 主要学习了sql中多表部分和多表查询:

学习多表首先要知道什么是约束;约束就是用来保证数据的完整性。单表中我们学习了主键约束,唯一约束,非空约束,在多表中又会学习一种新的约束-----外键约束.

表之间关系:         1 一对一(不常用,因为可以直接在一个表中完成)  
2多对一
3多对多


建表原则:        1 一对一(
唯一外键对应
假设是一对多，在多的一方创建外键指向一的一方的主键，将外键设置为unique。
主键对应
将两个表的主键建立对应关系即可。
)

2 多对一(多的一方设置外键指向一的一方主键!
)

3 多对多(建立中间表,至少设置2个字段作为外键分别指向多的表的主键!
)



多表查询:
1.交叉连接: 查到的是两个表笛卡尔积
select * from 表1 cross join 表2;
select * from 表1,表2;

2.内连接:inner join(inner可省略)
1)隐式内连接:select * from 表1,表2 where 关联条件;
2)显示内连接:select * from 表1 inner join 表2 on 关联条件;

3  外连接:outer join(outer 可省略)
1)左外连接:select*from 表1left join 表2 on关联条件
2)右外连接:select*from 表1right join 表2 on 关联条件



4  子查询:一个查询语句条件需要依赖另一个查询语句的结果
1)带In的子查询://查询学生生日在91年之后的班级的信息
select * from classes where cid in (SELECT cno FROM student WHERE birthday > '1991-01-01');


2)带exists的子查询://查询学生生日大于91年1月1日，如果记录存在，前面的SQL语句就会执行
select * from classes where exists (SELECT cno FROM student WHERE birthday > '1991-01-01');


3)带any的子查询:// 要大于最小值
SELECT * FROM classes WHERE cid > ANY (SELECT cno FROM student )


4)带all的子查询://要大于最大值
SELECT * FROM classes WHERE cid > ALL (SELECT cno FROM student)

柯威龙
今天学习了多表的查询 多表查询有有一对多,多对多,一对一查询.主要学习了一对多查询和多对多查询.
多对多的话需要建立一个中间表,中间表的话至少有两列,分别指向双方的主键.一对多的话我们需要在多
的那一个表创建一个外键指向一的主键.
多表查询有连接查询,子查询,连接查询里面有着交叉连接,内连接和外连接,交叉连接学习到了笛卡尔积
一半来说交叉连接用的比较少. 最有印象的是内连接和外连接.内连接也分为隐式内连接和显示内连接
外连接分为左外连接和右外连接左右连接唯一差别在 left 和 right两个单词上.学了一个新单词
union可以左右外连接全部显示.子查询的话就是SQL语句里面嵌套一个SQL语句来查询结果
事务的话只知道大概一个作用,具体的没有听懂.

谢洪彬:
        今天学习了SQL多表
外键:一个约束,用来保证数据的完整性
外键:一般用于有对应关系的两个表,设置外键可以让数据按规定的范围输入;
多表,言外之一就是多个表的意思,那么表与表之间又有多个关系 如下:
表与表的关系:  
一对多 :在多的一方创建外键指向一的一方的主键
多对多 :创建一个中间表至少两列分别设为外键指向两个表的主键
一对一 : 一对一一般不常使用,因为如果是一对一的话就直接在表后面再加一列就好了,没有必要在创建一个表.
应为表查询的功能很强大,也很经常需要操作,所以在多表查询的时候又有各种的连接关系,如下:
表查询之间的各种关系
内连接
1.显示连接
表与表之间使用关键字 inner join 连接 ,条件使用  on
2.隐式连接   
表与表之间使用 ,(逗号)来连接 条件使用where
外连接
1.左外连接
表与表之间使用 left join 连接, 条件使用 on 意思是左边表为主导
2.右外连接
表与表之间使用 right join 连接, 条件使用 on 意思是右边表为主导

今天还学习了事务,隔离性讲的比较多,隔离等级分为4个等级 ,每个等级的权限不同,作用也有区别.不过不是今天的重点,了解了解,后面在学习

侯玉林

今天我们讲了多表,主要有一对多,多对多,一对一三种类型.
然后又讲了该如何去用sql语句去对多表进行增删改查的操作,
主要还是select.有交叉连接,内连接(分显式和隐式),以及外连接
最后讲了事务和它的隔离级别

郑雪平

今天学习了多表设计,多表查询和事务与事务的隔离级别.在进行多表设计的同时要创建有外键
约束,因为这样才能保证数据的完整性.


     还有需要理清表与表之间的关系,总共分为:一对多关系,多对多关系和一对一这三种关系;一对

多关系我们可以拿班级与学生的关系来做举例说明;多对多关系的阐述可以使用学生与课程的关系

来举例说明;一对一关系则可以用人员与身份证的关系来加以解释说明,因为一个人只能拥有一张身

份证,一张身份证只能被一个人使用,这就是一对一关系;

      多表查询就显得比较复杂些,在进行多表查询前需先做数据准备,而且它还分为1.交叉连接;

2.显示连接;3.隐式连接;4.内连接;5.外连接,还有一个子查询,总共分为四种,其中带IN的子查询较为常

用所有也比较重要.

陈强
MySQL多表的一天,从外键开始,到表与表之间的关系,再到对多表查询的处理,总体来讲都是不复杂的SQL语句,
内连接根据不同的关键字分为两类:
Where---隐式
Join---显示
外连接根据主表格的位置,也分为两类:
左外连接---left  join on
右外连接---right join on
另外一个子查询中的带in的子查询也是重点
一个拓展的自表查询也是很实用的,将同一张表格根据实用者的不同,定义为不用名字的两个表格,再根据定义出来的表格的名字,去使用\比较等操作.

王刘锁
2018-5-25-SQL多表查询
一,当多张表之间有某种关系也就是外键约束的时候可以用一条sql语句来同时查询这
多张表~外键约束的作用是保证多表间数据的完整性!避免乱加误删数据等非常理操作.
语法操作 alter table 表1名 add foreign key (属性名1) reference (表2的属性2)
把表1的属性1设为外键指向表2的属性2.这时两张表就通过属性1和属性2相关连.前提
是两个属性是本身就相同的内容比如员工表的部门编号和部门表的部门编号.外键的添
加要看表间的关系,表间有一对多,多对多和一对一三种关系我们把多的设置外键指向
一的主键建立多表的关系.多对多关系的表的创建原则是需要创建一张存放两个外键分
别指向两张表的主键的中间表.操作的也是中间表.
查询两张表是的正确语法是:select * from 表1,表2 where 表1.属性1=表2.属性2 ;
条件就是通过外键查找.
二,多表查询的方式:
1,连接查询
交叉连接(一般用不到):查到的是两个表的记录数的乘积笛卡尔积,cross join  
select * from 表1 cross join 表2 ;或select * from 表1,表2 ;
内连接inner可以省略:
select * from 表1 inner join 表2 on 表1外键=表2主键 ;显式
select * from 表1,表2 where 表1外键=表2主键; 隐式
外连接:;左/右外链接 左为主右为辅/右为主左为辅 主的全显示辅的只显示匹配主的
left/right可以省略:select * from 表1 left/right outer join 表2 on 条件
子查询:查询工资和职位和 smith相同的所有员工信息
select * from emp where sal=(SELECT p.sal from emp p where p.ename='smith')
or job = (SELECT p.job from emp p where p.ename='smith')

郑阳阳
外键约束:用来保证多表之间数据的完整性
顺便提下单表约束有主键约束,唯一约束和非空约束.
多表操作:
表与表的关系:
多表间的关系有一对多,多对多,一对一(不常用,因为一对一一般可以直接在表中添加列,特殊需要才用到)
一对多,比如班级对学生的关系,一个班级有很多学生,一个学生只属于一个班级,
一对多建表需要添加外键,在多的一方添加,也就是班级与学生,在学生表中添加外键.
多对多,比如学生和课程的关系,学生可以选择很多课程,课程也会被很多学生选择,
多对多建表需要建立一个中间表中至少有两个字段来分别指向另外两个表的主键.
多表查询:
多表查询有交叉连接(不常用),内连接和外连接.
内连接分为隐式内连接和显示内连接.
隐式内连接:select * from 表名1,表名2 where 表名1.主键=表名2.主键.
显示内连接:select * from 表名1 inner join 表名2 where 表名1.主键=表名2.主键.(inner可以省略)
外连接分为左外连接和右外连接.
左外连接:select * from 表名1 left outer join 表名2 where 表名1.主键=表名2.主键(outer可以省略)
右外连接:select * from 表名1 right join 表名2 where 表名1.主键=表名2.主键.
左外连接是左边表匹配右边表,右外连接右匹配左.
内连接显示的两表之间能匹配上的数据,外连接多显示左或右多出的内容.
子查询:一个SQL需要另一个SQL查询.
事务:指的是逻辑上的一组操作,组成这组操作的各个逻辑单元,要么全部失败,要么全部成功.
事务的隔离级别分为:
read uncommitted：脏读,不可重复读，虚读都有可能发生,效率最高.
read committed：避免脏读.但是不可重复读和虚读是有可能发生.
repeatable read：避免脏读和不可重复读,但是虚读有可能发生.sql中的默认隔离级别.
serializable：避免脏读,不可重复读，虚读,效率最低

刘文峰

外键约束的作用是保证多表之间数据的完整性
外键约束的添加有以下几种方式:
1.一对多:在多的一方设置外键,指向一的主键
2.多对多:创建一个中间表,从两个表中至少取一列都设置成外键分别指向两个表的主键
3.一对一:两个表的主键设置外键,外键设置为唯一
多表查询方式:
1.交叉连接:cross join
Select * from 表1 cross join 表2;  或 select * from 表1,表2;
将每个可能性都查询出来(查到的记录数量为两个表记录的乘积)
2.内连接: inner join; inner可省略;分显示连接和隐式连接;只查询两个表之间关联的属性
显示连接 select * from 表1 inner join 表2 on 关联条件; 显示连接用on代替where
隐式连接 select * from 表1,表2 where 关联条件;  隐式连接不变;
3,外连接:outer join  outer可省略  分为左外连接 left 和右外连接 right
左外连接 select * from 表1 left join 表2 on 关联条件; leftjoin左边的表为主表,可显示里面的全部记录,不显示表2有但表1里没有的记录
右外连接 select * from 表1 right join 表2 on 关联条件;  参照左外连接;
多表查询的子查询:  四个关键字  in  exists   any  all
A:查询语句1 in(查询语句2);将查询语句2结果是一个范围,将其作为查询语句1的条件
B:查询语句1 exists (查询语句2);  查询语句2的结果为true或false,为true执行查询语句1
C:查询语句1 any (查询语句2); 满足查询语句2的最小条件即可执行
D:查询语句1 any (查询语句2); 满足查询语句2的最大条件方可执行


事务指的是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么全都成功，要么全都失败。事务有四个特性:原子性  一致性  隔离性  持久性;  
Start  transaction 开启事务;  保存当前状态的数据
Commit; 提交事务;  操作全部正确是才能提交成功;并结束事务
Rollback; 回滚事务;  将数据还原到开启事务时的状态;
多个事务并发时可能会引起安全问题:脏读,不可重复读,虚读
提高事务的隔离等级可避免问题的发生:
read uncommitted        ：脏读，不可重复读，虚读都有可能发生;效率最快但安全性最低
read committed        ：避免脏读。但是不可重复读和虚读是有可能发生,
repeatable read        ：避免脏读和不可重复读，但是虚读有可能发生。
Serializable       : 不会发生安全问题,但是效率最低

苏海斌
今天主要讲了MySQL的多表,以及一个外键约束(用来保证数据的完整性).
多表结构就会有表与表的关系,包括一对多,多对多,以及一对一(了解就好,用的不多),
多表的重点就是查询:
包含内连接和外连接,其中内连接分为两种,即隐式和显式,至于关键字
隐式用where,显式用join  on,
例:
Select * from user , dept  where user.did = dept.did   and 条件;

Select * from user (inner) join dept  on  user.did = dept.did  and 条件;
其中显式的inner可省略;
而外连接也分为两种,即左外连接和右外连接,其实就是看左边作为主表还是右边作为主表.
另外还提了一下子查询(即一条SQL语句的条件中包含另一条SQL语句)
最后,下午讲了事务,大概的提了下脏读,不可重复读,虚读等..

张育辉
六 多表查询
                                1:外键约束 alter table 表名 add foreign key (多的表名) references 哪张表(列名);
                                        作用:增加安全,防止胡乱修改,增加约束
                                2:多表关系
                                                -对多(一个教室有多个学生,一个学生只有一个教室,在多的表上添加外键)
                                                一对多的建表原则:在多的一方创建外键指向一的一方的主键
                                                多对多(一个学生可以选择多个课程,一门课程可以被多个学生选择,需要创建中间表,创建外键至少2个字段分别指向两张表的主键);
                                                多对多的建表原则:要创建中间表，中间表中至少两个字段，分别作为外键指向多对多双方的主键
                                                一对一(一个教室只有一个地址,一个地址只有一个教室)外键指向类型必须要唯一,这种做法没有意义;
                                3:内连接
                                         显示连接 select * from 表名1  inner join 表名2 on 条件筛选取交集;
                                         隐示连接 select * from 表名1 , 表名2 where 条件筛选取交集;
                                4:外连接
                                        左外连接 select * from 表名1  left outer join 表名2 on 条件筛选;outer可以省略不写
                                        右外连接 select * from 表名1  right outer join 表名2 on 条件筛选;outer可以省略不写        
                                        (两个区别就是看那张表是主表)
                                5:子连接  就是条件嵌套,一个查询语句条件需要依赖另一个查询语句的结果
                                        带in的子查询 in(1,2,3),就是满足1,2,3都可以
                                        带exists的子查询  select * from 表名 where exists (条件1);如果条件1满足前面的SQL语句就会执行
                                        带any的子查询 SELECT * FROM 表名 WHERE cid > ANY (条件1 ),只有满足里面一条就可以
                                        带all的子查询 SELECT * FROM 表名 WHERE cid > ALL (条件1),大于所有
                                6:自连接 ,就是自己把自己当做参照物
                                
                                7:事务：指的是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么全都成功，要么全都失败。
                                          开启事务:start transaction  //建档
                                                提交事务:commit;
                                                回滚事务:rollback;回滚就是数据库修改错误,可以回到建档之前,回到开启事务之前的数据
                                8:事务的特性：原子性
                                                                原子性：事务的不可分割，组成事务的各个逻辑单元不可分割。
                                                                一致性
                                                                事务执行的前后，数据完整性保持一致
                                                                隔离性
                                                                隔离性：事务执行不应该受到其他事务的干扰。
                                                                持久性
                                                                持久性：事务一旦结束，数据就持久化到数据库中。
                                9:隔离性：一个事务的执行，不应该受到其他事务的干扰。
                                                        如果不考虑隔离性（一个事务执行受到其他的事务的干扰），引发一些安全问题，主要体现在读取数据上：
                                                        脏读：一个事务读到了另一个事务未提交的数据，导致查询结果不一致
                                                       不可重复读：一个事务读到了另一个事务已经提交的update的数据，导致多次查询结果不一致。
                                                      虚读/幻读：一个事务读到了另一个事务已经提交的insert的数据，导致多次查询结果不一致。
                                10:设置事务的隔离级别：
                                                                        read uncommitted        ：脏读，不可重复读，虚读都有可能发生
                                                                        read committed        ：避免脏读。但是不可重复读和虚读是有可能发生
                                                                repeatable read        ：避免脏读和不可重复读，但是虚读有可能发生。
                                                                serializable ：避免脏读，不可重复读，虚读。

林玮
今天学了mysql多表和mysql事务,其实主要就是多表了,因为今天一天时间事务就讲了30分钟左右,而且以后会有一天时间来接着学这个事务了.

    外键约束:外键约束是一个针对表与表之间的的约束,他有三个关系,第一个就是[一对多]:一个表的如果设置一个外键,那么他就可以指向另一个表的一个主键(主键可以是多个),指向的这个主键就不能随便添加数了,只能添加设置了外键的表里的一些数,主要用于员工表与部门表,学生表与班级表,等等...[多对多]:外键约束多对多通俗来讲就是,你去商场买东西,你可以买多件商品,而一件商品也可以被多个人买,这就是多对多关系.多对多的指向你要通过的三张表,也就是再创建一张表,我们称它为中间表,它的主要作用是让一个表中的一列可以指向另一个表中的列,而这两列必须要为主键,让两表中其他外键通过主键指向你所指定的地儿,主要用于客户表与商品表,应聘员表,公司表,等等...[一对一]:辉哥说没什么意义,我听了一下也觉得没什么意义,明明可以只用一个表完成的是为什么要,再创建一个表找事呢?  非空约束: 约束元素不能为空;唯一约束:不能重复; 主键约束:就结合前两个约束既不能记录不能为空,也不能重复,一个表中只能有一个主键,其实主要就是外键约束,其他的没什么逻辑.今天的知识点也不难,只要多敲多练,慢慢的你就懂了.

许剑鸿 webDay09

外键约束是用来保证数据的完整性。

约束：
主键约束：可以确定一条记录，既不能为空，也不能重复。
唯一约束：不能重复，但是可以为空   
非空约束：不能为空，可以重复
外键约束：外键约束是用来保证数据的完整性。（员工和部门）

表和表之间的关系
一对多：在多的一方创建外键指向一的一方的主键（学生和班级，在学生表中创建外键指向班级的主键）
多对多：必须创建中间表，中间表至少两个列分别作为外键指向两张表的主键
一对一:不常见 因为可以直接列在一个表中

多表查询：

交叉连接：两张表的笛卡尔积
A.        就是多张表的乘积
B.        Select * from user , dept

内连接：两张表的交集
A.        隐式  关键字：   ....   ， ....   where
a)        Select * from user , dept  where user.did = dept.did   and 条件;
B.        显式  关键字：   inner join  ....   on
a)        Select * from user (inner) join dept  on  user.did = dept.did  and 条件;

外链接：主表全部，从表部分。
左外：关键字  left join
A. Select * from  user  left join dept  on   user.did = dept.did
右外：关键字  right join
A. Select * from  dept  right  join  user  on   user.did = dept.did

自连接：自己和自己连接   
例子： select  *  from  emp a  ,  emp b  where  a.mgr = b.empno

子查询
一条sql语句的条件中包含了另一条sql语句

Select * from user ,dept where user.did = dept.did  and sal = (Select  sal  from user  where         name=’smith’);

Select  sal  from user  where         name=’smith’ //查询的是史密斯的工资----执行结果：
工资

16weisong
今天学习了sql多表操作和事务的入门知识,事务部分知识属于了解,重点是sql多表关系,及多表查询,多表查询主要有2部分:连接查询和子查询.连接查询又分为:交叉连接,内连接和外连接,后面两个属于重点,前面那个属于了解部分.今天其实只要把辉哥给的作用练习都做了,比较复杂的多写几遍,就能掌握这两天数据库的知识.

江某人:

        mysql:
        约束是用来保证数据的完整性。
        单表约束:
        主键约束
        唯一约束
        非空约束

        多表设计:
        一对多：在多的一方创建外键指向一的一方的主键.
        多对多:创建中间表,中间表至少两个字段，分别指向双方主键.
        一对一(很少用):将一对一的双方的主键建立映射.
        交叉连接:select * from A,B;   --- 获得的是两个表的笛卡尔积
        内连接:
        隐式内连接：select * from A,B where 条件;
        显式内连接：select * from A inner join B on 条件;
        外连接:
        左外连接：left outer join  -- select * from A left outer join B on 条件;
        右外连接：right outer join -- select * from A right outer join B on 条件;
       
       

        事务三步骤
        开启事务：
        start transaction;
        提交事务
        commit;(也等于关闭事务)
        回滚事务
        rollback;(在没关闭当前事务都能回滚到开启事务前)
        设置事务的隔离级别：
        read uncommitted        ：脏读，不可重复读，虚读都有可能发生
        read committed        ：避免脏读。但是不可重复读和虚读是有可能发生
        repeatable read        ：避免脏读和不可重复读，但是虚读有可能发生。
        serializable                ：避免脏读，不可重复读，虚读。
        设置事务隔离级别格式
        SET SESSION TRANSACTION ISOLATION LEVEL 事务隔离级别;

李志勇:
mysql:
约束是用来保证数据的完整性。
单表约束:
        主键约束
        唯一约束
        非空约束
表与表之间的关系：
        一对多: 多对多, 一对一
交叉连接:cross join
交叉连接：查询到的是两个表的笛卡尔积。
语法：
select * from 表1 cross join 表2;
select * from 表1,表2;
内连接:inner join(inner是可以省略的)
显示内连接：在SQL中显示的调用inner join关键字
语法：select * from 表1 inner join 表2 on 关联条件;
隐式内连接：在SQL中没有调用inner join关键字
语法：select * from 表1,表2 where 关联条件;
外连接:outer join(outer可以省略的)
左外连接：
语法：select * from 表1 left outer join 表2 on 关联条件;
右外连接
语法：select * from 表1 right outer join 表2 on 关联条件;
在子查询中
个人认为  in 代表包含  exists 代表是否存在  返回boolean值 形式if
any 任何   all  全部,
事务三步骤
开启事务：
start transaction;
提交事务
commit;(也等于关闭事务)
回滚事务
rollback;(在没关闭当前事务都能回滚到开启事务前)
设置事务的隔离级别：
read uncommitted        ：脏读，不可重复读，虚读都有可能发生
read committed        ：避免脏读。但是不可重复读和虚读是有可能发生
repeatable read        ：避免脏读和不可重复读，但是虚读有可能发生。
serializable                ：避免脏读，不可重复读，虚读。
设置事务隔离级别格式
SET SESSION TRANSACTION ISOLATION LEVEL 事务隔离级别;