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

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

吴利君
    今天学习的了数据库的进阶知识数据库的多表操作以及事务的管理，首先，我们学习的是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

白有旺
多表:以两张表的id字段信息相同作为条件建立两表关联，但在实际开发中不应该这样使用，最好用主外键约束来实现
在实际项目开发过程中经常用到从一个信息较为完善的表中派生出一个只含有几个关键字段的信息表，通过子查询就可以来实现这一目标
Java事务控制是构建J2EE应用不可缺少的一部分，合理选择应用何种事务对整个应用系统来说至关重要。一般说来，在单个JDBC 连接连接的情况下可以选择JDBC事务，

我们知道单表中一定会有一个主键,这个主键主要是用来方便我们取某一条数据 ,就像人的身份证号码一样/
外键可以比喻成3张表,一张表是学生表,一张表是课程表,一张表则是成绩单,成绩单上面有学生的学号及对应的成绩,那么学生表中的学号是学生表中的主键,因为一个学号对应一个人,课程表中的课程编号是课程的主键,成绩单上面有着学号和课程编号,所以成绩单中有着学生表和课程表的外键,如果说成绩单写了错误的学号或者错误的课程编号,那么SQL就会报错,这种外键约束保证了数据的安全性和严密性

外键sql语句
在创建时增加
　　　create table my_tab1(
　　　id int primary key auto_increment,
　　　name varchar(10) not null,
　　　class int,
　　　foreign key(class)　references my_tab2(主键字段名);
　　　)charset utf8;
　　 在创建好的表中增加
　　　alter table my_tab1 add [constraint 外键名] foreign key(外键字段名) references mytab2(主键字段名);
删除外键
　　alter table my_tab drop foreign key 外键名字;
语法：
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 事务隔离级别;

邵倩


多表:一条sql 操作多个表

可以通过ER图来看两表直接是否有关系  

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

主键约束:确定一条记录,既不能为空,也不能重复
唯一约束:可以为空,不能重复

外键约束,用来保证多表直接的数据完整性

添加外键约束
1.在员工表上添加外键
alter table employee add foreign key(dno) refrences dept(did)
insert into employee values(,,,)

表和表之间的关系

一对多:员工和部门;用户和订单
在多的一方创建外键指向一的一方的主键

多对多:学生和课程
需要创建中间表,其中至少两个字段分别作为外键 指向多对多双方的主键

一对一(很少使用,因为可以直接在表里添加一列):公司和注册地址
假设一对一是一个一对多关系,需要在多的一方创建外键指向一的一方的主键,将其设置成唯一unique

多表查询的概述
多表查询的分类 1.连接查询:(很少使用)交叉连接cross join---查询到的是两个表的笛卡尔积,
内连接:     显示内连接 在sql中显式地调用inner join 关键字---select*from表1inner join表2 on 关联条件,inner可以省略
                   隐式内连接：在SQL中没有调用inner join关键字---select * from 表1,表2 where 关联条件;

隐式显式除了写法没有区别 用哪个都行

外链接:左外链接 left join  on,右外链接right join  on

自连接:select * from emp a,emp b where a.mgr=b.empno


多表查询中的子查询

查询工资比 smith更高的全部员工信息
select * from emp where sal+ifnull(comm,0)>(select sal from emp where ename='smith');
select sal from emp where ename='smith';

查询学生生日在91年之后的班级的信息
select * from classes where cid in (SELECT cno FROM student WHERE birthday > '1991-01-01');

事务 通常是DML
开启事务 相当于存档
提交事务 生效再结束事务
回滚事务 还原到存档的位置再结束事务

叶凌青
今天主要讲了SQL对多表记录操作
分为:
一对多：在多的一方创建外键指向一的一方的主键
多对多:创建中间表,中间表至少两个字段，分别指向双方主键
一对一：（很少）
多表查询：
连接查询
主要
内连接: inner join -- inner 可以省略
隐式内连接：select * from A,B where 条件;
显式内连接：select * from A inner join B on 条件;
外连接outer join -- outer 可以省略
左外连接：left outer join  -- select * from A left outer join B on 条件;
右外连接：right outer join -- select * from A right outer join B on 条件;
子查询
一个SQL需要依赖另一个SQL语句的查询结果

吴鹏

--------------------------------------------
多表:
外键约束:保证多表之间数据的完整性;
约束保证数据的完整性;

一张表的一个字段名指向另一张表的主键字段;
当外键设置为非空字段时,添加字段的时候,外键不能为空;

表与表的关系(重点)

一对多
一个部门有许多个员工,一个员工只属于某一个部门;
在多的一方创建外键指向一的一方的主键;

多对多
一个学生可以选择多门课程,一门课程可以被多个学生选择;
要借助第三张表(中间表,在这张表中至少有两个字段,分别作为外键指向双方的主键)

一对一
一个公司可以有一个注册地址,一个注册地址也只能对应一个公司;

唯一外键对应的方式:
假设一对一是一个一对多的关系,需要在多的一方创建外键指向一的一方的主键
将外键设置为唯一(unique);

主键对应的方式:
直接将两张表的主键进行外键的设置;

-------------------------------------------------------
多表查询的分类
连接查询:
    交叉查询
        查询到的时两个表的笛卡尔乘积
        select * from 表1 cross join 表2;
        select * from 表1,表2;
    内连接 关键字:inner join(inner可以省略)
        显示内连接:在sql中显示的调用关键字
        语法:select * from 表1 inner jion 表2 on 关联条件(表1.字段名=表2.字段名);
        隐式内连接 在sql中没有调用关键字
        语法:select * from 表1,表2 where 关联条件;
    外连接 关键字:outer join(outer 可以省略)
        左外连接 表1为主表,主表全部显示,从表根据主表匹配来显示;
        语法:select * from 表1 left outer join 表2 on 关联条件;
        右外连接 表2为主表,主表全部显示,从表根据主表匹配来显示;
        语法 select * from 表1 right outer join 表2 on 关联条件;

----------------------------------------------

事务:
逻辑上的一组操作(DML),组成这组操作的各个逻辑单元,要么全部成功,要么全部失败
原子性
不可分割,组成事物的各个逻辑单元不可分割
一致性
事务执行的前后,数据的完整性保持一致;
隔离性
事务执行不应该受到其它事务的干扰
多个事务在并发;
持久性
事务一旦结束,数据就持久化到数据库中;

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

隔离性级别:
1 Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。

2 Repeatable read (可重复读)：可避免脏读、不可重复读的发生。

3 Read committed (读已提交)：可避免脏读的发生。

4 Read uncommitted (读未提交)：最低级别，任何情况都无法保证。

以上四种隔离级别最高的是Serializable级别，最低的是Read uncommitted级别，
级别越高，执行效率就越低。所以平时选用何种隔离级别应该根据实际情况。
在MySQL数据库中默认的隔离级别为Repeatable read (可重复读)。

郑志祥Mysql（多表）个人笔记

  今天复习了单表的特点，1,唯一约束2,非空约束 3,主键约束（刚好包含前面两点）
学习了多表，多表特点：用来保证数据的完整性，（比如；部门还有人，就无法直接删除部门，解决办法  1.先删除人，再删除部门    2.将人调到别的部门，再删除部门）

多表中有三种关系  ；      
一对多(教室和学生) 在教室表中创建外键 指向学生表

  多对多(课程和学生) 需要创建中间表 表中有两个字段作为外键指向两张表的主键

  一对一(公司和地址)         唯一外键对应方式:假设是一个一对多关系,在多的一方创建外键指向单个的主键,将外键设置成唯一(unique)



,多表查询的方式:
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主键; 隐式（比较常见）

外连接:;左/右外链接 左为主右为辅/右为主左为辅 主的全显示辅的只显示匹配主的
格式:select * from 表1 left/right outer join 表2 on 条件
条件 （where 表1.属性1=表2.属性2 ;）
注释：如果左外连接，说明左边是主表，全部显示，右边没有用null补齐
如果右外连接，说明右边是主表，全部显示，左边没有用null补齐

子查询:（嵌套）查询工资和职位和 smith相同的所有员工信息
select * from emp where sal=(SELECT p.sal from emp p where p.ename='smith') 
注释；从emp表查询工资=（从emp表查询 p.工资， 令emp为p  p.名字为smith ）
or job = (SELECT p.job from emp p where p.ename='smith')
从emp表查询 p.工种， 令emp为p  p.名字为smith






   事务（了解，后面继续学习）
事务:指的是逻辑上的一组操作,组成这组操作的各个逻辑单元,要么全部成功,要么全部失败.

开启事务
        start transaction
提交事务
        commit
回滚事务
        rollback
隔离性：一个事务的执行，不应该受到其他事务的干扰。
如果不考虑隔离性（一个事务执行受到其他的事务的干扰），引发一些安全问题，主要体现在读取数据上：
事务的隔离级别
由低到高     
 read uncommitted        ：脏读，不可重复读，虚读都有可能发生
read committed        ：避免脏读。但是不可重复读和虚读是有可能发生
repeatable read        ：避免脏读和不可重复读，但是虚读有可能发生。
serializable                ：避免脏读，不可重复读，虚读。

郑学馨
外键有什么作用:保证数据的完整性
怎么添加外键;利用可视化工具进行外键设置
表与表之间的关系:一对多;多对多;一对一
外键的创建:外键连接一般创建在多的一方;

多对多关系的创建规则:在两表之间创建第三表,且该表至少得存

在两列;

连接方式:
内连接:(隐式内连接:select * from student inner join

class on student.id=class.csid;
/显式内连接:select * from student ,class where

student.id=class.csid;)

外连接:(左外连接:select * from student left join class

on student.id=class.csid;
/右外连接:select * from student right join class on

student.id=class.csid;)
二者区别:确定的主表不一样,左外表示join左边的表为主表,右

外则表示join右边的表为主表;主表就是主表内的所有选项都必

须在结果中显示,不管附表是否有包含主表的内容;

什么是子查询:sql语句嵌套查询

什么事物:俗称后悔药,

事物的特性(面试):原子性,一致性,隔离性,持久性

黄志彬
外键约束就是用来保证数据的完整性；
给表取别名让表看起来更加简洁明了。

表与表的关系：
一对多，在多的那一方设置外键指向一的一方主键；
多对多，创建一个中间表从两个表中至少取一列都设置成外键分别指向两个表的主键；
一对一，两个表的主键设置外键,外键设置为唯一；
多表的查询：
交叉连接，两张表的笛卡尔积。
内连接，相当于两张表的交集。
隐式内连接；
显示内连接；
外连接，主表的全部，从表的部分
左外连接；
右外连接；
自连接：自己跟自己连接

MySQL 事务主要用于处理操作量大，复杂度高的数据：原子性，一致性，隔离性，持久性。
开启事务：start transaction;
提交事务: commit;(也等于关闭事务)
 回滚事务: rollback;    
事物的隔离级别
Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。
Repeatable read (可重复读)：可避免脏读、不可重复读的发生。
Read committed (读已提交)：可避免脏读的发生。
Read uncommitted (读未提交)：最低级别，任何情况都无法保证。
最高的是Serializable级别，最低的是Read uncommitted级别，级别越高，执行效率就越低。

施炎生
1.添加外键约束
alter table 表名 add foreign key(列名) references 表名(列名);
设置外键不允许为空
alter table 表名 modify 列名 类型 not null;
2. 查询多表的方式
  a.交叉连接:使用cross join关键字 (可以不写cross)
  select * from 表名1 cross join 表名2;
  select * from classes,student;
  b.内连接:使用inner join和on 关键字(又叫显示内连接,可以不写inner)
  select * from 表名1 inner join 表名2 on 连接条件
  不使用inner join和on 关键字(又叫隐式内连接)
  select * from 表名1 , 表名2 where 连接条件
  c.外连接:使用left outer join关键字(叫做左外连接,可以不写outer)
  select * from 表名1 left outer join 表名2 on 连接条件
  使用rigth outer join关键字(叫做右外连接,可以不写outer)
  select * from 表名1 rigth outer join 表名2 on 连接条件
3.子查询:
  a.带in的子查询: select * from classes where cid in (SELECT cno FROM student WHERE birthday > '1991-01-01');
  b.带exists的子查询: select * from classes where exists (SELECT cno FROM student WHERE birthday > '1991-01-01');
  c.带any的子查询: SELECT * FROM classes WHERE cid > ANY (SELECT cno FROM student );
  d.带all的子查询: SELECT * FROM classes WHERE cid > ALL (SELECT cno FROM student);       

凌辉:
今天学习了mysql的多表
多表分为一对多,多对多,一对一;
一对多的外键为多的一方创建外键指向一的一方的主键;
多对多先创建出中间表,表创建出两列主键,分别连接两个表;


内连接是两张表的被同时覆盖到的地方;
外连接分为左右,左外连接为左边那个球,右外连接为右边那个球
还学习了子查询:in,exists,any,all

康元中
学习mysql 多表的操作
表和表的关系分为
  表和表一对一关系: 如公司的地址和公司的id
表和表一对多的关系:如学生和班级关系 / 部门和员工关系
表和表的多对多关系:如学生和课程/商品和订单
操作多张表通过设置外键操作: 一对多时将外键设置在多的那张表下 指向对应表的主键
                                          多对多设置中间表然后在该中间表添加关联表的外键分别指向对应的主键
设置外键能够起到约束的作用保证数据的完整性,: 1 设置主键上的字段的数据类型和添加外键的字段的数据类型保持一致;
                                                                  2. 设置外键就无法对数据的任意更改
  添加外键方式两种: 分别是cmd 控制台输命令 和 工具sqyol创建和添加

2  多表查询
   多表查询之链接查询
    交叉连接: 查询到的是两个表的笛卡尔积
                                        selct *from 表一 cross jion 表二
                                        select *from 表一,表二;
内连接: 显示内连接和隐式内连接 inner join (关键字inner 可以省略)
显示内连接: select *from 表一 inner join  表二 on 关联条件
隐式内连接:select *from 表一 , 表二where  关联条件

外连接: 分为左外连接和右外连接 outer join (outer 可以省略)
左外连接语法格式:  select *from 表一 left outer join 表二  on 关联条件
右外连接语法格式:  select *from 表一 right outer join 表二  on 关联条件

子查询: 一条sql 语句中的条件中包含另一条sql语句; 带in 子查询;带exists的子查询, 带any子查询,带all
        如 : 查询学生生日在91年之后的班级的信息。
        select * from classes where cid in (SELECT cno FROM student WHERE birthday > '1991-01-01');

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

   

吴俊斌
学习了什么是约束,就是为了保证数据的完整性,约束类型要一致,长度也要一致.
还学习了三种数据关系
       一对多,一对一,多对多(要用中间表来建立关系)
还学习了多表查询
        交叉连接:
           内连接
                 显性 select * from 表一 cross(可省略) join 表二;
                 隐性 select * from 表一 , 表二;
                 查询的是所有出现的组合(两表乘积)
           外连接:
                  select * from 表一 (left或者right) join 表二;分别代表左外和右外 加条件要用on
                 
                  查询的是所有出现的组合(两表交集加上left或者right对应表的所有内容)

还学习了子查询(一个查询语句条件需要依赖另一个查询语句的结果):
        in:包含查询
        exist:存在查询
        any:部分查询,大于最小,小于最大
        all:所有查询

林荣彬
      今天主要学习了多表的之间的关系和外键约束的创建,事务特性的了解.,重点学习了多表的查询.
外键约束:是用来保证数据的完整性;

表和表的关系:
一对多:在多的一方创建外键指向
多对多:需要创建中间表，中间表中至少两个字段，分别作为外键指向多对多双方的主键

多表查询的分类:
1: 连接查询分为:
  1.交叉连接:
  2.内连接:
     显示内连接:在SQL中显示的调用inner join关键字
     隐式内连接:在SQL中没有调用inner join关键字
  3.外连接:
      左外连接:在SQL中调用left  outer join
      右外连接:在SQL中调用right  outer join

2: 子查询:一条SQL语句的条件中包含另一条QSL语句
1. 带in(包含)的子查询
2. 带exists(存在)的子查询
3. 带any(任意的)的子查询
4. 带all(所有)的子查询


事务的特性:
原子性:事务的不可分割,组成的事务的各个逻辑单元不可分割
一致性:事务执行的前后,数据完整性一致
隔离性:一个事务的执行不应该受都其他事

万冕

今天主要学了约束，主建约束唯一且不为空 非空约束，外键约束数据完整性。

多表的多对多，主要是多表的查询，select * from 表名 where 条件
显示内连接   select * from 表名  inner join 表名2 on 条件；

隐式内连接   select * from 表名， 表名2 where 条件；
  
还有左外连接 SELECT * FROM 表名 left join 表名2 on 条件 ;
右外连接 SELECT * FROM 表名 right join 表名2 on 条件 ;

还是一样的主要敲代码熟练代码，熟练！！！

Day09

今天学习的内容为MySQL多表(重点)和事务(了解).
MySQL多表:
我的理解:多表是位于MySQL数据库中的多个表格,多个表格是用来存储不同关系的数据,通过不同关系的表格
但是又有相关联的属性来进行数据的增删查功能,今天对多表的学习主要是表与表之间的关系,约束,多表的查询.

多表的约束:外键约束,外键约束的意思是将表与表之间相关联的属性进行约束限制,作用保护数据的完整性,在
需要对数据进行增删改操作时,需要符合外键约束条件才能操作成功.

多表的关系:关系分为一对多,多对多,一对一.
一对多:在定义为多的表格对象上创建外键指向定义为单一的表格对象的主键.
例子:员工和部门,员工为多的表格对象,部门为单一的表格对象,一个部门有多个员工,一个员工只能有一个部门
多对多:创建中间表的外键指向两张表的主键.
例子:学生和课程,一个学生可以有多个课程,一个课程也可以有多个学生.
一对一:同一张表格,通过共同属性来查询相关信息.
例子:每个人的身份证都是一一对应.

多表查询:交叉连接,内连接,外链接,自连接,子查询
交叉连接:笛卡尔积,多张表的乘积.
内连接:两张表的交集,分为隐式内连接与显示内连接.
隐式内连接:select * from emp e,dept d where e.deptno = d.deptno and 条件;
显示内连接:select * from emp e (inner) join dept d on e.deptno = d.deptno and 条件;
外链接:主表的全部加上从表的部分,外链接分为左外链接,右外链接,左右方向均是指向主表.
左外链接:select * from emp e left (outer) join dept d on e.deptno = d.deptno;
右外链接:select * from emp e right (outer) join dept d on e.deptno = d.deptno;
自连接:自己与自己连接,select * from emp e,emp e1 where e.mgr = e1.emptno;

子查询:SQL语句的条件为另外的SQL语句,分为in,exist,any,all的子查询.
in:包含查询
exist:存在查询
any:部分查询,大于最小,小于最大
all:所有查询

张述明
今天学习多表查询和事务
多表查询中使用到一个因素就是外键 外键是用来保证数据的完整性
要学会多表查询先要理解表单之间的关系
比如一对多的关系 例子 员工和部门 外键的创建要在多的一方创建外键指向一的一方的主键
多对多的关系 需要创建一个中间表 中间表至少要有两个外键指向另外两个表的主键 例子学生和课程
一对一的关系 例如 公司和公司的注册地址 . 分成唯一外键对应 和主键对应的方式.
多表的查询  连接查询  
交叉连接  select*from 表1,表2;
内连接: select* from inner join 表2 on关联条件
外链接: select* from outer join 表2 on关联条件
子查询分成带in,exists,any,all 的子查询 其中in是重点

事务
开启事务 start transaction
提交事务  commit
回滚  rollback
特性
原子性,一致性,持久性,隔离性.
事务的隔离性的级别不同可预防不同的问题 隔离的等级越高效率越低越安全
可能引发的问题如脏读 不可重复读 和虚读.

许煜
mysql总结
外键约束 保持多表之间元素完整性
一对多 建表原则 多的一方创建外键指向1的那方主键
多对多 创建中间表 中间表至少两个外键指向双方主键
多表查询 交叉连接 笛卡尔积 select* from tab1, tab2  //select * from tab1 cross join tab2
内连接 显:select* from tab1 inner join tab2 on 关联条件
        隐 select * from tab1, tab2 where 关联条件    两表交集
外链接 select * from tab1 left/right outer join tab2 on 条件 (inner/outer可省略)
子查询 一条sql语句包含另一条sql语句
Select * from tab1 where in/exist/any/all(sql语句)
事务  开启start transaction   提交commit   返回 rollback
今天主要学习目标就是做到灵活查询多表内容

颜琳琳
  
   今天主要学了,多表的创建和查询以及多表的关系,多表的关系中分为:1. 一对一 2.多对多 3.一对多,主要掌握多对多和一对多两个关系,一对多中要有创建一个外键,在多的那个表格中添加一个外键(外键是用来约束数据的完整性); 多对多中要创建一个中间表,中间表中至少两个字段，分别作为外键指向多对多双方的主键;
多表中的创建的连接主要有:1. 内连接(关键词:inner join):显示内连接和隐示内连接2.外连接(关键词:outer join):左外连接和右外连接 (注意: 外连接和内连接主要区别在于两个连接的查询的内容的不同,内连接查询的是两个表共有内容,而外连接查询的是两个表共有的内容和其查询的不是共同的内容.  3.自连接:顾名思义就是自己连自己.
子查询:就是一个SQL语句中在写一个SQL语句,其中有1. 带有in子查询,2.带有exists的子查询,3.带有any的子查询,4.带有all的子查询,这些子查询主要掌握in,其他掌握即可.
学习了事务,它是一组逻辑上的操作,这一组操作的各个单元,要么成功,要么失败; 它的特性有:1.原子性,2.隔离性,3.持久性,4.一致性;