今天学习了对多表的操作
多表有一对一的关系(不常用,出特殊需求,一般用不上,都写在同一张表上)
还有一对多和多对多的关系 这两个是常见的关系
一对多 创建联系时在多的一方设置外键 指向 一的主键;
外检具有约束作用,不得随意填写,只能写联系表主键上有的值, 外键和其主键的类型等都需要一样(非空不要求一样)
难点在于多对多的表联系的创建, 因为两张表都是多的关系,随意要通过创建第三张表来简历关系,在第三张表上 设置两个外键 分别对应两张表的主键,对于由多对多的关系产生的结果,我们也必须在第三张表上体现;(比如 多个学生选择多们课程, 这样每个学生对应的课程成绩 我们就得写在第三张表上)
子语句  一条语句里包含另一条完整的语句,这个语句通常作为条件或是条件的一部分 来实现第一条语句.
简单了解了事务,产生的问题是由事务并发产生的,  一般的问题会有 脏读,不得重复读写,虚读,这些问题我们可以通过设置隔离级别来阻止;

今天学习了对多表的操作
多表有一对一的关系(不常用,出特殊需求,一般用不上,都写在同一张表上)
还有一对多和多对多的关系 这两个是常见的关系
一对多 创建联系时在多的一方设置外键 指向 一的主键;
外检具有约束作用,不得随意填写,只能写联系表主键上有的值, 外键和其主键的类型等都需要一样(非空不要求一样)
难点在于多对多的表联系的创建, 因为两张表都是多的关系,随意要通过创建第三张表来简历关系,在第三张表上 设置两个外键 分别对应两张表的主键,对于由多对多的关系产生的结果,我们也必须在第三张表上体现;(比如 多个学生选择多们课程, 这样每个学生对应的课程成绩 我们就得写在第三张表上)
子语句  一条语句里包含另一条完整的语句,这个语句通常作为条件或是条件的一部分 来实现第一条语句.
简单了解了事务,产生的问题是由事务并发产生的,  一般的问题会有 脏读,不得重复读写,虚读,这些问题我们可以通过设置隔离级别来阻止;

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

陈叶隆
1.1, 多表设计：i) 一对多：在多的一方创建外键指向一的一方的主键
                         ii) 多对多:创建中间表,中间表至少两个字段，分别指向双方主键
1.2, 多表查询：i) 内连接: 隐式内连接：select * from A,B where 条件; 显式内连接：select * from A join B on 条件;
ii) 外连接: 左外连接：select * from A left join B on 条件; 右外连接：select * from A right join B on 条件;
iii) 子查询:
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);

詹源
今天学习了多表设计,多表查询,以及事务的概述(初步了解,日后深入学习);

多表之间必须用外键约束来保证数据完整性

如何在表上添加外键:
alter table 表名 add foreign key(列名)references dept(列名);
设置外键为非空:
alter table 表名 modify 列名 int not null;

表之间关系分三种:
一对多
多对多
一对一;

不同关系之间建表原则:
一对多:多的一方创建外键指向一的一方的主键;
多对多:创建中间表,中间表中至少两个字段,分别作为外键指向多对多双方的主键;
一对一:唯一外键对应,如果是一对多,多的一方创建外键指向一的主键.外键设置为unique.
       将两个表的主键建立对应关系即可

多表连接查询:
交叉连接cross join :select*from 表1,表2
获取两个表的笛卡尔积;即获取互相匹配所有记录的结果
内连接:
显示内连接:select*from 表1 inner join 表2 on 关联条件;(inner可以省略)(调用inner join)
隐式内连接:select*from 表1,表2 where 关联条件;(没有调用inner join)
外连接:outer join(outer 可以省略)
左外连接:select*from 表1 left outer join 表2 on 关联条件;
右外连接:select*from 表1 right outer join 表2 on 关联条件;

事务:逻辑上一组操作.组成这组操作的各个逻辑单元,要么全部成功,要么全部失败;
流程:
        开启事务
        提交事务
        回滚事务
        提交事务
特性:
原子性:组成事务的各个逻辑单元不可分割
一致性:数据完整性保持一致
隔离性:执行不受其他事务干扰
持久性:事务结束后,数据持久化到数据库中;

叶身辉:
今天学习了mysql的多表查询,首先学习了如何添加给一个表格添加外键,然后学习了表格与表格之间对应的关系,有一对一(比较少,主键对应就好了),一对多,和多对多的关系,
主要知识点有left join 左外连接查询 right join右外连接查询 外连接查询的时候条件要用on不能用where, 子查询 带in 包含的意思,带exists如果存在sql就执行不存在就不执行,any任意一个,带all所有的,uniou去重复,
还学习了事务,主要了解了事务start transaction 开启事务,commit 提交事务,
rollback回滚,以及隔离区分四个级别.

外键约束：表A的主关键字是表B中的字段，外键是用来实现参照完整性

多表连接

左外连接：... left outer ... on 关联条件，左表的所有字段和右表匹配字段

右外连接：... right outer ... on 关联条件，右表的所有字段和左表的匹配字段

全外连接：  用union 连接 左外连接和右外连接

内连接：  where a.id = b.id  等值匹配

自连接： 将自身分成两张表。可以进行等值连接或者外连接

子查询：
其实就是嵌套查询，需注意返回值是多行还是单行。

事务的特性：
1.原子性
2.一致性
3.隔离性
4.持久性

事务的隔离级别：
1.脏读
2.不可复读
3.虚读

何平波
多表约束
外键约束:用来保证数据完整性(多表),某个数据为null,就不能添加外键,外键的值不允许为空,外键的作用是保证数据不会被操作失误胡乱修改

表与表的关系
一对多   例子 :班级和学生   部门和员工

如何添加外键
例如在一对多的关系表中,在多表中添加外键,先在多表中添加外键名和外键栏指向一表中的主键.

一对多建表的原则
例如在一对多的关系表中,在多表中添加外键,先在多表中添加外键名和外键栏指向一表中的主键
多对多的关系
多对多   例子 :学生和多门课程  用户对商品
借助第三张(中间表)
多对多建表的原则
创建中间表 ,在中间表中至少两个字段,分别作为外键指向多对的主键

一对一的关系
一对一   例子 :企业和企业网址
唯一外键对应的方式:
假设是一对多,在多的一方创建外键指向一的一方的主键,将外键设置为unique
主键对应方式
将两个表的主键建立对应关系即可.

交叉连接
1.使用cross join 关键词
sllect * from 表名1 cross join 表名2;
2.不使用cross join关键字
select * from 表名1,表名2;   (效果与使用cross in关键字一样)
查询到的是表1和表2全部的元素

内连接
1.显式内连接(使用inner(可省略) join on关键字, 得到的是两张表共有的数据,
以主键的表和外键的表来获取数据)
select * from 表名1 x join 表名2 x on x.主键=x.外键
x代表的是可以为表名改名,防止数据库判断不出你要查询的是哪个表的值.
2.隐式内连接
select * from 表名1 x,表名2 x where x.主键=x.外键
x代表的意思同上.  其实显示和隐式内连接的获取数据的写法效果是一样的,获取到的都是表1和表2共有的数据.
  
外连接(查询到的是某个表的内容和它与另一个表的共有内容)
关键字:outer(可省略) join on
左外连接 left outer join
select * from 表名1 x left outer join 表名2 x on x.主键=x.外键
x代表同上,这个写法的意思是获取在左边的表名1的数据和表1表2共有的数据,
注意:表2的没有对应值的数据就会用null值表示

右外连接 right outer join
select * from 表名1 x right outer join 表名2 x on x.主键=x.外键
x代表同上,这个写法的意识是获取在右边的表名2的数据和表1表2共有的数据,
注意:表1的没有对应值的数据就会用null值表示

子查询(sql语句的嵌套)  因子查询都是条件判断,所以要在where后
带in的子查询
用法在in()里嵌套一些查询方法;
带exists的子查询(exists代表是否存在记录)
用法在exists()里嵌套一些查询方法
带any的子查询(任意一个记录)
用法在any()里嵌套一些查询方法
带all的子查询(所有的记录)
用法在all()里嵌套一些查询方法

事务
理解:事务：指的是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么全都

成功，要么全都失败。
方法: start transaction 开启事物
      commit 提交事物
      rollback 回滚事物,返回事物
特点:1.原子性  事务不可分割,组成事务的各个逻辑单元不可分割
     2.一致性  事务执行的前后,数据完整性保持一致.
     3.隔离性  事务执行不应该受到其他事务的干扰.
     4.持久性  事物一旦结束,数据就会持久化到数据库中.

陈世彪:
今天学习了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 条件;
可以不加outer  
子查询中的 in(范围查找)
select * from 表一 where 列名 in(select....条件);
事务是一系列的操作,保证数据和业务逻辑的完整性
开始事物
start TRANSACTION
要执行的sql语句
最后提交结束
可以用commit或者rollback回退
sql默认安全等级为repeatable read;
为了解决并发使用serializable

颜琳琳
  
   今天主要学了,多表的创建和查询以及多表的关系,多表的关系中分为: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.一致性;

许煜
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
今天主要学习目标就是做到灵活查询多表内容

张述明
今天学习多表查询和事务
多表查询中使用到一个因素就是外键 外键是用来保证数据的完整性
要学会多表查询先要理解表单之间的关系
比如一对多的关系 例子 员工和部门 外键的创建要在多的一方创建外键指向一的一方的主键
多对多的关系 需要创建一个中间表 中间表至少要有两个外键指向另外两个表的主键 例子学生和课程
一对一的关系 例如 公司和公司的注册地址 . 分成唯一外键对应 和主键对应的方式.
多表的查询  连接查询  
交叉连接  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
特性
原子性,一致性,持久性,隔离性.
事务的隔离性的级别不同可预防不同的问题 隔离的等级越高效率越低越安全
可能引发的问题如脏读 不可重复读 和虚读.

曾耀峰  
  今天学习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

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 表名 where 条件
显示内连接   select * from 表名  inner join 表名2 on 条件；

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

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

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

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

多表查询的分类:
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 表一 cross(可省略) join 表二;
                 隐性 select * from 表一 , 表二;
                 查询的是所有出现的组合(两表乘积)
           外连接:
                  select * from 表一 (left或者right) join 表二;分别代表左外和右外 加条件要用on
                 
                  查询的是所有出现的组合(两表交集加上left或者right对应表的所有内容)

还学习了子查询(一个查询语句条件需要依赖另一个查询语句的结果):
        in:包含查询
        exist:存在查询
        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 事务隔离级别;

   

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


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

施炎生
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);