黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业6期-每日总结】Mysql多表查询与事务的操作 [打印本页]

---

作者: 厦门校区    时间: 2019-4-11 11:29
标题: 【厦门校区JavaEE就业6期-每日总结】Mysql多表查询与事务的操作
1.什么情况下会用到表连接查询?
2.表的连接查询有几种?
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
4.什么是事务，什么是提交，什么是回滚?
5.mysql有几个隔离级别?
6.数据库并发访问问题都有哪些?

---

作者: 陈伟彬    时间: 2019-4-11 21:03
1.什么情况下会用到表连接查询?
答：
        如果直接一次性查询多张表，就会出现笛卡尔积现象；为了消除笛卡尔积现象，因此就采用表连接查询；

2.表的连接查询有几种?
答：
        内连接查询：内连接只能查询到两表有交集的信息，如果没有交集，则会被认为错误信息，不会被显示出来；
        外链接查询：查询表的所有数据和该表的交集部分；
        子查询：查询中嵌套查询，嵌套查询为子查询；


3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：
        子查询：查询中嵌套查询，嵌套查询为子查询；
        情况与使用：
                当查询结果为单行单列时：可直接作为条件，能用运算符进行判断；
                当查询结果为多行单列时：可以直接作为条件，用 运算符 in 来判断 ；
                当查询结果为多行多列时：可以作为一张虚拟表参与查询；

4.什么是事务，什么是提交，什么是回滚?
答：
        事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败；
        提交：将开启事务后改变的数据，进行永久保存；
        回滚：将数据回档成开启事务前的状态；

5.mysql有几个隔离级别?
答：
        四种；
                读未提交：read uncommitted；
                读已提交：read committed；
                可重复读：repeatable read；
                串行化：serializable；
        安全级别从上往下一次增加，但效率逐渐下降；

6.数据库并发访问问题都有哪些?
答：
        脏读：一个事务，读取到另一个事务没有提交的数据；
        不可重复读 (虚读)：在同一个事务中，两次读取到的数据不一样；
        幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改；

---

作者: 庄家琦    时间: 2019-4-11 21:03
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 龚荣章    时间: 2019-4-11 21:03
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 黑马六期-董安平    时间: 2019-4-11 21:03
1.什么情况下会用到表连接查询?
答：
需要查询的数据必须通过多张表才能完全获取，这时候可以使用表连接查询。
2.表的连接查询有几种?
答：表连接查询有三种
        1.内连接
        1）隐式内连接
        select * from employee department where 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2）显式内连接
        select * from employee inner join department on 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2.外连接
        1）左外连接
                语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                展示数据：
                会将左边（表1）中所有的数据（包括null值）全部展示，
                然后会展示右边（表2）与左边（表1）交集
        2）右外连接
        语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
        展示数据：
                会将右边（表1）中所有的数据（包括null值）全部展示，
                然后会展示左边（表2）与右边（表1）交集
        3.子查询
                嵌套在查询语句中的查询语句


3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：
子查询：
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号
        1. 子查询的结果是单行单列的：
        * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        2. 子查询的结果是多行单列的：
        * 子查询可以作为条件，使用运算符in来判断 in （select ....）
        3. 子查询的结果是多行多列的：
        * 子查询可以作为一张虚拟表参与查询  并且我们会给虚拟表起名字
4.什么是事务，什么是提交，什么是回滚?
答：
事务：是将多条sql语句 统一管理 要么同时成功 要么 同时失败
提交：当事务执行完后，进行保存的步骤称之为提交
回滚：当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
答：
四个级别
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化

6.数据库并发访问问题都有哪些?
答：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 郑海波    时间: 2019-4-11 21:08

1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 厦门第六期刘鹏    时间: 2019-4-11 21:08
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 厦门第六期刘鹏    时间: 2019-4-11 21:09

厦门第六期刘鹏 发表于 2019-4-11 21:08
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一 ...

加油，请继续坚持下去！

---

作者: 罗加铭    时间: 2019-4-11 21:15
1.什么情况下会用到表连接查询?
答：当需要同时查询多张表的内容时，就会用到表连接查询

2.表的连接查询有几种?
答：
1. 内连接
1) 隐式内连接
        select * from employee,department where 条件
                条件就是: employee,department 的关联关系
                        如果多于两张表 那么需要找到所有表之间的关联关系
                                               
2) 显式内连接
        select * from employee [inner] join department on 条件
                条件就是: employee,department 的关联关系
                        如果多于两张表 那么需要找到所有表之间的关联关系
                               
2. 外连接
1) 左外连接
        语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                展示数据:
                        会将左边(表1)中所有的数据(包括null值)全部展示
                                ,然后会展示右边(表2)与左边(表1) 交集
                               
2) 右外连接
        语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
                展示数据:
                        会将右边(表2)中所有的数据(包括null值)全部展示
                                然后会展示左边(表1)与右边(表2) 交集

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：子查询是嵌套在查询语句中的查询语句
        由于查询语句 结果不一样 我们分为了三类:
        1. 子查询的结果是单行单列的：
                * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        2. 子查询的结果是多行单列的：
                * 子查询可以作为条件，使用运算符in来判断  in (Select ...)
        3. 子查询的结果是多行多列的：  
                * 子查询可以作为一张虚拟表参与查询 并且我们会给虚拟表起名字

4.什么是事务，什么是提交，什么是回滚?
答：
事务： 如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
提交 :  commit   发现执行没有问题，提交事务
回滚 ：rollback  发现执行出问题了，回滚事务

5.mysql有几个隔离级别?
答：四个隔离级别：
1. read uncommitted：读未提交
        * 产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）
        * 产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）
        * 产生的问题：幻读
4. serializable：串行化
        * 可以解决所有的问题

6.数据库并发访问问题都有哪些?
答：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据。
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 陈前凌    时间: 2019-4-11 21:16
1.什么情况下会用到表连接查询?
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种?
1.内连接查询,
       隐式内连接:使用WHERE条件消除无用的数据
       显示内连接:使用join作为消除无用的数据
2. 外链接查询
       左外连接 使用关键字left join 来关联两个表,他会查询左表的说有数据和右表的交集部分
       右外连接 使用关键字rightjoin 来关联两个表,他会查询右表的说有数据和左表的交集部分
3.子查询
        用一条SQL语句的结果作为另外一条语句的条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
查询中嵌套查询，像Java中的链表结构，被称为子查询
单行单列：作为条件使用，使用运算符判断： > >= < <= =
多行单列：作为条件使用，使用运算符in判断
多行多列：可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交后内容将保存到硬盘中，持久化的保存数据在事务提交前遇到问题可以使用回滚返回事务开始时的值

5.mysql有几个隔离级别?
有read uncommitted、read committed、 repeatable read、serializable 四种

6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据。
不可重复读：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作数据表中的所有记录，，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 卢勇炜    时间: 2019-4-11 21:17
1.什么情况下会用到表连接查询?
答：当我们想查询一个人的名字和他所在的部门的名字，则需要使用多表查询；
2.表的连接查询有几种?
答：1.内连接查询：（1）隐式内连接（2）显式内连接；
    2.外连接查询：（1）左外连接  （2）右外连接
    3.子查询：（1）单行单列 （2）多行单列 （3）多行多列
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答:有查询的嵌套，内部的嵌套查询被称为子查询；有三种情况：
（1）结果是一个值  ：SELECT 查询字段 FROM 表 WHERE 字段=（子查询）
（2）结果是多行单列：SELECT 查询字段 FROM 表 WHERE 字段 IN （子查询）
（3）结果是多行多列：SELECT 查询字段 FROM （子查询） 表别名 WHERE 条
4.什么是事务，什么是提交，什么是回滚?
答：（1）一个包含多个步骤的业务操作(sql语句)，被事务管理，操作要么同时成功，要么同时失败。
    （2）如果事务中 SQL 语句没有问题，commit 提交事务，会对数据库数据的数据进行改变。
    （3）如果事务中 SQL语句有问题，rollback 回滚事务，会回退到开启事务时的状态
5.mysql有几个隔离级别?
答：mysql有四个隔离级别；
6.数据库并发访问问题都有哪些?
答：脏读；不可重复读；幻读

---

作者: 黑马林伟明    时间: 2019-4-11 21:18
1.什么情况下会用到表连接查询?
答：
需要查询的数据必须通过多张表才能完全获取，这时候可以使用表连接查询。
2.表的连接查询有几种?
答：表连接查询有三种
        1.内连接
        1）隐式内连接
        select * from employee department where 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2）显式内连接
        select * from employee inner join department on 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2.外连接
        1）左外连接
                语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                展示数据：
                会将左边（表1）中所有的数据（包括null值）全部展示，
                然后会展示右边（表2）与左边（表1）交集
        2）右外连接
        语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
        展示数据：
                会将右边（表1）中所有的数据（包括null值）全部展示，
                然后会展示左边（表2）与右边（表1）交集
        3.子查询
                嵌套在查询语句中的查询语句


3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：
子查询：
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号
        1. 子查询的结果是单行单列的：
        * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        2. 子查询的结果是多行单列的：
        * 子查询可以作为条件，使用运算符in来判断 in （select ....）
        3. 子查询的结果是多行多列的：
        * 子查询可以作为一张虚拟表参与查询  并且我们会给虚拟表起名字
4.什么是事务，什么是提交，什么是回滚?
答：
事务：是将多条sql语句 统一管理 要么同时成功 要么 同时失败
提交：当事务执行完后，进行保存的步骤称之为提交
回滚：当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
答：
四个级别
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化

6.数据库并发访问问题都有哪些?
答：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 龙舟    时间: 2019-4-11 21:19
1.什么情况下会用到表连接查询
  当一个表不能完整的查找到我们所需要的数据时,需要用到表连接查询
2.表的连接查询有几种
   内连接查询,
       隐式内连接:使用WHERE条件消除无用的数据
       显示内连接:使用join作为消除无用的数据
   外链接查询
       左外连接 使用关键字left join 来关联两个表,他会查询左表的说有数据和右表的交集部分
       右外连接 使用关键字rightjoin 来关联两个表,他会查询右表的说有数据和左表的交集部分
   子查询
        用一条SQL语句的结果作为另外一条语句的条件
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
    用一条SQL语句的结果作为另外一条语句的条件
    查询的结果是单行单列的,直接使用算数运算符使用.
    查询结果是多行单列的,使用运算符in来判断
    查询结果是多行多列的,可以把查询出来的表作为一个虚拟表参与查询.
4.什么是事务，什么是提交，什么是回滚
    如果一个包含多个步骤的业务操作,被事物管理,那么这些操作要么同时成功,要么同时失败,提交就是当确认数据正确
无误时,提交数据,他会把数据持久化的保存在硬盘中.回滚,当事务中的SQL语句出现错误的时候,使用回滚语句,可以回滚
到事务开启时的状态
5.mysql有几个隔离级别
   1. 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
   2. 持久性：当事务提交或回滚后，数据库会持久化的保存数据。
   3. 隔离性：多个事务之间。相互独立。
   4. 一致性：事务操作前后，数据总量不变
6.数据库并发访问问题都有哪些
   1. 脏读：一个事务，读取到另一个事务中没有提交的数据
   2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
   3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 陈鉴    时间: 2019-4-11 21:19
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 黄杰南    时间: 2019-4-11 21:20
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: zhaizhile    时间: 2019-4-11 21:20
1.什么情况下会用到表连接查询?
查询结果在多张不同的表中。

2.表的连接查询有几种?
分为内连接(包括隐式内连接和显示内连接)和外连接(包括左外连接和右外连接)

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号

1) 子查询的结果是单行单列
2) 子查询的结果是多行单列
3) 子查询的结果是多行多列

1)子查询结果只要是单行单列，肯定在 WHERE 后面作为条件，父查询使用：比较运算符，如：> 、<、<>、=等
SELECT 查询字段 FROM 表 WHERE 字段=（子查询）;

2)子查询结果是单例多行，结果集类似于一个数组，父查询使用 IN 运算符
SELECT 查询字段 FROM 表 WHERE 字段 IN （子查询）;

3)子查询结果只要是多列，肯定在 FROM 后面作为表
SELECT 查询字段 FROM （子查询） 表别名 WHERE 条件;

4.什么是事务，什么是提交，什么是回滚?
事务执行是一个整体，所有的 SQL 语句都必须执行成功。如果其中有 1 条 SQL 语句出现异常，则所有的SQL 语句都要回滚，整个业务执行失败

事务提交是提交事务的所有操作：具体来说就是将事务中所有对数据库的更新写回到磁盘上的物理数据库中，事务正常结束；

事务回滚是数据库返回到事务开始的状态：事务在运行过程中发生某种故障，事务不能继续执行，系统将事务中对数据库的所有已完成的更新操作全部撤销，使数据库回滚到事务开始时的状态。
5.mysql有几个隔离级别?
1 读未提交 read uncommitted
2 读已提交 read committed  
3 可重复读 repeatable read
4 串行化 serializable

6.数据库并发访问问题都有哪些?
脏读:一个事务读取到了另一个事务中尚未提交的数据

不可重复读 :一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是致的，这是事务 update 时引发的问题

幻读: 一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致
的，这是 insert 或 delete 时引发的问题

---

作者: 开心的小孩    时间: 2019-4-11 21:24
陈鹏涛
1.什么情况下会用到表连接查询?
       需要查询的数据必须通过多张表才能完全获取，这时候可以使用表连接查询
2.表的连接查询有几种?
      1. 内连接查询：
         隐式内连接：使用where条件消除无用数据 。
        显式内连接 语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件
      2. 外链接查询：
                 左外连接：
                * 语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                * 查询的是左表所有数据以及其交集部分
     .           右外连接：
                * 语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
                * 查询的是右表所有数据以及其交集部分。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
     * 概念：查询中嵌套查询，称嵌套查询为子查询
     1. 子查询的结果是单行单列的：
      *   子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
          子查询的结果是多行单列的：
          子查询可以作为条件，使用运算符in来判断
         子查询的结果是多行多列的：
      *  子查询可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚?
  1. 概念：
     *  如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
    - - 发现执行没有问题，提交事务
                COMMIT;
     -- 发现出问题了，回滚事务
                ROLLBACK;
5.mysql有几个隔离级别?
   1. read uncommitted：读未提交
                        * 产生的问题：脏读、不可重复读、幻读
  2. read committed：读已提交 （Oracle）
                        * 产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）
                        * 产生的问题：幻读
4. serializable：串行化
6.数据库并发访问问题都有哪些?
  1. 脏读：一个事务，读取到另一个事务中没有提交的数据
  2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
  3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 陈志铖    时间: 2019-4-11 21:28
1.什么情况下会用到表连接查询?
需要查询的数据必须通过多张表才能完全获取，这时候可以使用表连接查询。
2.表的连接查询有几种?
内连接查询：
        隐式内连接
        显式内连接
        内连接查询
外链接查询
        左外连接
        右外连接
子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号
        子查询的结果是单行单列的：
        * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        子查询的结果是多行单列的：
        * 子查询可以作为条件，使用运算符in来判断 in （select ....）
       子查询的结果是多行多列的：
        * 子查询可以作为一张虚拟表参与查询  并且我们会给虚拟表起名字
4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
当事务执行完后，进行保存的步骤称之为提交
当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
四个级别
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 陈弘帅    时间: 2019-4-11 21:30
1.什么情况下会用到表连接查询?
需要查询的数据必须通过多张表才能完全获取，这时候可以使用表连接查询。
2.表的连接查询有几种?
内连接查询：
        隐式内连接
        显式内连接
        内连接查询
外链接查询
        左外连接
        右外连接
子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号
        子查询的结果是单行单列的：
        * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        子查询的结果是多行单列的：
        * 子查询可以作为条件，使用运算符in来判断 in （select ....）
       子查询的结果是多行多列的：
        * 子查询可以作为一张虚拟表参与查询  并且我们会给虚拟表起名字
4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
当事务执行完后，进行保存的步骤称之为提交
当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
四个级别
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 李煜霖    时间: 2019-4-11 21:32
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 李伟艺    时间: 2019-4-11 21:33

1.什么情况下会用到表连接查询
答：当想要输出的数据位于多个表时会用到表连接查询。
2.表的连接查询有几种
答：多表查询的分类：
    1. 内连接查询：
        1. 隐式内连接：使用where条件消除无用数据
        2. 显式内连接：
            * 语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件
    2. 外链接查询：
        1. 左外连接：
            * 语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
            * 查询的是左表所有数据以及其交集部分。
        2. 右外连接：
            * 语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
            * 查询的是右表所有数据以及其交集部分。
    3. 子查询：
        * 概念：查询中嵌套查询，称嵌套查询为子查询。
        * 子查询不同情况
            1. 子查询的结果是单行单列的：
                * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
            2. 子查询的结果是多行单列的：
                * 子查询可以作为条件，使用运算符in来判断
            3. 子查询的结果是多行多列的：
                * 子查询可以作为一张虚拟表参与查询
                -- 普通内连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
        * 概念：查询中嵌套查询，称嵌套查询为子查询。
        * 子查询不同情况
            1. 子查询的结果是单行单列的：
                * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
            2. 子查询的结果是多行单列的：
                * 子查询可以作为条件，使用运算符in来判断
            3. 子查询的结果是多行多列的：
                * 子查询可以作为一张虚拟表参与查询
                -- 普通内连接

4.什么是事务，什么是提交，什么是回滚
答：<1>. 事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
事务提交的两种方式：
<2>.提交：（1） 自动提交：
        * mysql就是自动提交的
        * 一条DML(增删改)语句会自动提交一次事务。
        （2）手动提交：
        * Oracle 数据库默认是手动提交事务
        * 需要先开启事务，再提交
<3>.回滚（Rollback）指的是程序或数据处理错误，将程序或数据恢复到上一次正确状态的行为。回滚包括程序回滚和数据回滚等类型。
5.mysql有几个隔离级别
答：隔离级别：
        1. read uncommitted：读未提交
            * 产生的问题：脏读、不可重复读、幻读
        2. read committed：读已提交 （Oracle）
            * 产生的问题：不可重复读、幻读
        3. repeatable read：可重复读 （MySQL默认）
            * 产生的问题：幻读
        4. serializable：串行化
            * 可以解决所有的问题
6.数据库并发访问问题都有哪些
答：1. 脏读：一个事务，读取到另一个事务中没有提交的数据
    2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
    3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 黑马6期陈华    时间: 2019-4-11 21:34
1.什么情况下会用到表连接查询?
答：
当所需要查找的数据分散在多张有相互关联的表中的时候，可以使用表连接查询。
2.表的连接查询有几种?
答：表连接查询有三种
        1.内连接
        1）隐式内连接
        select * from employee department where 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2）显式内连接
        select * from employee inner join department on 条件
                条件就是： employee，department的关联关系
                如果多于两张表 那么需要找到所有表之间的关联关系
        2.外连接
        1）左外连接
                语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                展示数据：
                会将左边（表1）中所有的数据（包括null值）全部展示，
                然后会展示右边（表2）与左边（表1）交集
        2）右外连接
        语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
        展示数据：
                会将右边（表1）中所有的数据（包括null值）全部展示，
                然后会展示左边（表2）与右边（表1）交集
        3.子查询
                嵌套在查询语句中的查询语句


3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：
子查询：
1) 一个查询的结果做为另一个查询的条件
2) 有查询的嵌套，内部的查询称为子查询
3) 子查询要使用括号
        1. 子查询的结果是单行单列的：
        * 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        2. 子查询的结果是多行单列的：
        * 子查询可以作为条件，使用运算符in来判断 in （select ....）
        3. 子查询的结果是多行多列的：
        * 子查询可以作为一张虚拟表参与查询  并且我们会给虚拟表起名字
4.什么是事务，什么是提交，什么是回滚?
答：
事务：是将多条sql语句 统一管理 要么同时成功 要么 同时失败
提交：当事务执行完后，进行保存的步骤称之为提交
回滚：当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
答：
四个级别
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化

6.数据库并发访问问题都有哪些?
答：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改，不会出现在mySql中。

---

作者: 林志鹏    时间: 2019-4-11 21:35
1.什么情况下会用到表连接查询?
当查询的数据在多张表的时候我们会用到将多张表组合。

2.表的连接查询有几种?
表的连接分为三种：
（1）内连接查询分为：①隐式内连接：where条件消除无用数据 ②显示内连接：join...on
（2）外连接查询：①左外连接：查询左表的所有数据和交集部分 ②右外连接：left改成right 查询右表的所有数据和交集部分
（3）子查询：③查询中嵌套查询

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：查询中嵌套查询，称嵌套查询为子查询
子查询的结果有三种情况：
第一种结果和使用：结果单行单列；作为条件用运算符去判断
第二种结果和使用：结果多行单列；作为条件用in来判断
第三种结果和使用：结果多行多列：作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务：就是多行SQL语句的操作要么同时成功，要么同时失败
提交：事务的结束语句，当手动开启的事务，执行确定没有问题后必须要使用commit提交对事务进行提交，否则事务显示的只是暂时的数据，只有提交事务后，数据才可以持久保存。
回滚：当执行过程中出现问题就不会执行而是会回到执行的原点：rollback

5.mysql有几个隔离级别?
mysql有四个隔离级别；
隔离级别：隔离级别从小到大安全性越来越高，但是效率越来越低
                        1. read uncommitted：读未提交
                                会产生的问题：脏读、不可重复读、幻读
                        2. read committed：读已提交 （Oracle）
                                会产生的问题：不可重复读、幻读
                        3. repeatable read：可重复读 （MySQL默认）
                                 会产生的问题：幻读
                        4. serializable：串行化
                                可以解决所有的问题
                               
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 徐代成    时间: 2019-4-11 21:36
1.什么情况下会用到表连接查询?

当我们需要查询的信息来源于多个表时，我们就需要用到夺标连接

2.表的连接查询有几种?

三种：
（1）内连接查询
（2）外链接查询
（3）子查询

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?

查询中间套查询，称嵌套查询为子查询。
子查询分为三种情况：
（1）子结果为单行单列，这是可以将结果直接用运算符判断
（2）子结果为多行单列，可以将子结果放入到in中运算
（3）子结果为多行多列，可以将子结果作为虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?

事务就是将多个SQL语句放在一起操作，这些语句要么全部成功，要么全部失败
提交就是结果运行OK后确认运行结果，中断事务
回滚就是结果运行NG，将运行状态恢复到事务开启前，中断事务

5.mysql有几个隔离级别

隔离级别：
1. read uncommitted：读未提交
2. read committed：读已提交
3. repeatable read：可重复读
4. serializable：串行化

6.数据库并发访问问题都有哪些?

存在问题：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 高坂火龙果    时间: 2019-4-11 21:37
黄志斌：
1.什么情况下会用到表连接查询
  当一个表不能完整的查找到我们所需要的数据时,需要用到表连接查询

2.表的连接查询有几种
   内连接查询,
       隐式内连接:使用WHERE条件消除无用的数据
       显示内连接:使用join作为消除无用的数据
   外链接查询
       左外连接 使用关键字left join 来关联两个表,他会查询左表的说有数据和右表的交集部分
       右外连接 使用关键字rightjoin 来关联两个表,他会查询右表的说有数据和左表的交集部分
   子查询
        用一条SQL语句的结果作为另外一条语句的条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
    用一条SQL语句的结果作为另外一条语句的条件
    查询的结果是单行单列的,直接使用算数运算符使用.
    查询结果是多行单列的,使用运算符in来判断
    查询结果是多行多列的,可以把查询出来的表作为一个虚拟表参与查询.

4.什么是事务，什么是提交，什么是回滚
    如果一个包含多个步骤的业务操作,被事物管理,那么这些操作要么同时成功,要么同时失败,提交就是当确认数据正确
无误时,提交数据,他会把数据持久化的保存在硬盘中.回滚,当事务中的SQL语句出现错误的时候,使用回滚语句,可以回滚
到事务开启时的状态

5.mysql有几个隔离级别
   1. 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
   2. 持久性：当事务提交或回滚后，数据库会持久化的保存数据。
   3. 隔离性：多个事务之间。相互独立。
   4. 一致性：事务操作前后，数据总量不变

6.数据库并发访问问题都有哪些
   1. 脏读：一个事务，读取到另一个事务中没有提交的数据
   2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
   3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 余建强    时间: 2019-4-11 21:37
1.什么情况下会用到表连接查询?
数据分散在多张表,需要要到其他表中的数据是需要用到表连接查询

2.表的连接查询有几种?
三种:
        (1)内连接
        (2)外连接:分为左外连接和右外连接
        (3)子连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
在一个查询中还含有另一个查询,子查询又分为三种情况,子查询的结果是单行单列,单行多列,多行多列
单行当列:一般用于条件查询,例如:< > <= >=
单行多列:一般用于in中充当数据
多行多列:一般用于充当一个临时表使用

4.什么是事务，什么是提交，什么是回滚?
事务是一组操作包含一个或者多个步骤,这组操作被事务管理,要么同时成功,用么同时失败
提交:事务操作成功,将操作后的数据永久保存到硬盘上
回滚:当事务操作中发生错误,数据回滚到事务发生时状态,数据也永久保存到硬盘上

5.mysql有几个隔离级别?
mysql有四种隔离级别
读未提交:不能解决任何安全问题
读已提交:可解决脏读
可重复读:可解决脏读和虚读(不可重复读)
串行读:可解决任何读操作,但缺点是过于耗费性能

6.数据库并发访问问题都有哪些?
脏读:一个事务读取到另一个事务未提交的数据
不可重复读(虚读):在同一个事务中,两次读取到的数据不一致
幻读:一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 黄振明    时间: 2019-4-11 21:38
1.什么情况下会用到表连接查询?
答：
当我们要查询两个表或者多个表的时候，而这样直接查询的话会出现笛卡儿积的现象，为了消除笛卡尔积现象，
我们采用多表连接查询。

2.表的连接查询有几种?
答：
内连接查询
        隐式内查询：使用where条件消除无用数据
        显示内查询：使用select 字段列表 from 表名1 [inner] join 表名2 on 条件 来消除无用数据。
        使用内连接查询要注意：
                1.从那些表中查询数据
                2.条件是什么
                3.查询哪些字段
外连接查询
        左外连接查询：
                语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
                查询的是左表中所有的数据以及和右表交集部分
        右外连接查询：
                语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；
                查询的是右表中所有的数据以及和左表交集部分
子查询
        查询中嵌套查询语句

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：子查询就是在查询中嵌入查询，被嵌套的称为子查询。
子查询的不同情况：
        1.子查询的结果是单行单列
                子查询可以作为条件，使用运算符进行去判断。 运算符：>、>=、<、<=、=
        2.子查询的结果是多行单列
                子查询可以作为条件，使用运算符in来判断。
        3.子查询的结果是多行多列
                子查询可以作为一张虚拟表参与查询。
       
4.什么是事务，什么是提交，什么是回滚?
答：
事务：如果一个包含多个步骤的业务操作，这些操作要么同时成功，要么同时失败。
提交：对事务操作后提交给数据库
回滚：对事务进行操作后，未提交给数据库时，可以进行回滚操作，对操作进行回档一次

5.mysql有几个隔离级别?
答：
mysql有4个隔离级别
        1.读未提交：read uncommitted
        2.读已提交：read committed        （Oracle默认）
        3.可重复读：repeatable read （MySQL默认）
        4.串行化：serializable

6.数据库并发访问问题都有哪些?
答:
存在的问题：
        1.脏读：一个事务，读取到另一个事务未提交的数据
        2.不重复读(虚读)：在同一个事务，两次读取到不同的数据
        3.幻读：一个事务操作(DML)数据中所有记录，另一个事务添加了一条数据，则第一个
        事务查询不到自己的修改。

---

作者: 林艺彬    时间: 2019-4-11 21:40
1.什么情况下会用到表连接查询?
一个表的内容无法满足我们的需求的时候需要从其他表获取数据会用到表连接查询。

2.表的连接查询有几种?
内连接查询：隐式内连接使用where清除无用数据；显示内连接inner join on
外连接查询：左外连接left outer join on查询左表所有数据以其交集部分；右外连接：right outer join on 查询右表所有数据以及其交集部分
子查询：查询中嵌套查

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：查询中嵌套查询，称嵌套查询为子查询
结果：
1）单行单列：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
2）多行单列：子查询可以作为条件，使用运算符in来判断
3）多行多列：子查询可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务： 如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交：commit，事务的提交语句，没有提交不能持久化到数据中。       
回滚：rollback是事务操作过程中发生错误时，可以回滚数据到开启事务时。
               
5.mysql有几个隔离级别?
* 隔离级别：
1) read uncommitted：读未提交
        * 产生的问题：脏读、不可重复读、幻读
2) read committed：读已提交 （Oracle）
        * 产生的问题：不可重复读、幻读
        我们在一些特定的场景下 需要保证一次书屋读取到的数据是一致的。
3) repeatable read：可重复读 （MySQL默认）
        * 产生的问题：幻读
4) serializable：串行化
        * 可以解决所有的问题  效率的降低
        当一个事物没有提交的时候 其他事物没有办法操作数据
* 注意：隔离级别从小到大安全性越来越高，但是效率越来越低

6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 吴越    时间: 2019-4-11 21:43
1.什么情况下会用到表连接查询?
答：当有多个表需要查询，需要消除笛卡尔积时会用到表连接查询

2.表的连接查询有几种?
答：表的连接主要分为两种，内连接和外连接：
其中，内连接有隐式和显式两种，隐式内连接使用where条件消除无用数据；显式内连接通过Inner join on语句消除无用数据。
外连接有左外连接和右外连接两种，左外连接查询左表所有数据以及其和右表交集部分，右外连接正好相反。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：查询中嵌套查询，称嵌套查询为子查询。子查询的结果有3种情况：
1. 子查询的结果是**单行单列**的：子查询可以作为条件，使用运算符去判断。
2. 子查询的结果是**多行单列**的：子查询可以作为条件，使用in(结果)来判断。
3. 子查询的结果是**多行多列**的：子查询可以作为一张虚拟表参与查询。

4.什么是事务，什么是提交，什么是回滚?
答：如果一个包含多个步骤的业务操作，这些操作要么同时成功，要么同时失败，称为被事务管理。
提交是事务操作成功时，将事务操作后的新数据永久化地保存在硬盘中。
回滚是事务操作失败时，将数据回滚到事务开始操作之前的状态，并永久化地保存在硬盘中。

5.mysql有几个隔离级别?
答：mysql有四种隔离级别：
1. read uncommitted：读未提交。产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）。产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）。产生的问题：幻读
4. serializable：串行化。可以解决所有的问题

6.数据库并发访问问题都有哪些?
答：数据库并发访问问题主要有三种：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 管文祥    时间: 2019-4-11 21:44
1.什么情况下会用到表连接查询?
答：当要查询的数据在不同的表中时,这时候就需要同时查询多个表,我们可以将不同表中的一列或多列数据取出，组合成一个新的临时表，用于连接查询。
2.表的连接查询有几种?
答：有三种：内连接查询，外连接查询和子查询
内连接查询又分隐式内连接和显示内连接：都是用来消除无用数据的；
外连接查询又分左外连接和右外连接：是为了查询一张表的所有数据以及其交集部分；
子查询：查询中嵌套的查询语句称为子查询，子查询又分为三种情况：单行单列，可作为条件，可参与运算符判断；多行单列：可作为条件使用关键字in来判断；多行多列：可作为一张虚拟表参与查询，
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：子查询：查询中嵌套的查询语句称为子查询，子查询又分为三种情况：单行单列，可作为条件，可参与运算符判断；多行单列：可作为条件使用关键字in来判断；多行多列：可作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚?
答：事务是一组包含多个步骤的业务操作，这组操作被事务管理，要么同时成功，要么同时失败。
5.mysql有几个隔离级别?
答：四个隔离级别：read uncommitted：读未提交； read committed：读已提交 （Oracle默认）；repeatable read：可重复读 （MySQL默认）； serializable：串行化
6.数据库并发访问问题都有哪些?
答：脏读：一个事务，读取到另一个事务中没有提交的数据。
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 叶彬彬    时间: 2019-4-11 21:46

1.什么情况下会用到表连接查询?
查询的内容涉及到多张表，就要用到表连接查询数据

2.表的连接查询有几种?
4种；
内连接查询：
  隐式内连接：使用where条件消除无用数据
  显式内连接：语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件
外链接查询：
  左外连接：语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；
  右外连接：语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：查询中嵌套查询，称嵌套查询为子查询。
有3种情况；
1. 子查询的结果是单行单列的。使用步骤：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
2. 子查询的结果是多行单列的。使用步骤：子查询可以作为条件，使用运算符in来判断
3. 子查询的结果是多行多列的。使用步骤：子查询可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务：一个包含多个步骤的业务操作，被统一管理，这些操作要么同时成功，要么同时失败。
提交：发现执行没有问题，提交事务
回滚：发现出问题了，回滚事务

5.mysql有几个隔离级别?
1. read uncommitted：读未提交。产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）。产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）。产生的问题：幻读
4. serializable：串行化。可以解决所有的问题

6.数据库并发访问问题都有哪些?
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 陈驰煜    时间: 2019-4-11 21:47
1.什么情况下会用到表连接查询?
当同时对多张表进行查询时, 会产生笛卡尔积现象, 使查询的结果错误,这时需要使用表连接查询
2.表的连接查询有几种?
3种,
1.内连接查询: 隐式内连接和显示内连接查询
2.外连接查询
左外连接查询和右外连接查询
3.子查询

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
在查询中嵌套查询语句,称为子查询
子查询的结果有3种:
1.单行单列: 将子查询的结果作为一个值, 可以使用运算符去判断
2.多行单列: 子查询的结果是多行单列的, 可以使用in判断结果是否在结果中
3.多行多列: 子查询的结果是一个表, 放在from语句后重命名为一个表

4.什么是事务，什么是提交，什么是回滚?
一个包含多条sql语句的业务操作被事物管理, 这些操作要么同时成功, 要么同时失败
操作:
开启事物(start transaction)
回滚事物(rollback): 将表恢复到至开启事务之前的状态
提交事物(commit): 确定更改表的内容

5.mysql有几个隔离级别?
隔离级别：
1. read uncommitted：读未提交    * 产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）    * 产生的问题：不可重复读、幻读       
3. repeatable read：可重复读 （MySQL默认）    * 产生的问题：幻读       
4. serializable：串行化(锁表)     * 可以解决所有的问题, 一个事物开启时, 只要还没有commit其他事物就无法访问表


6.数据库并发访问问题都有哪些?
存在问题：
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 曾伟清    时间: 2019-4-11 21:50
1.什么情况下会用到表连接查询?
答：消除笛卡尔积即两张表或者多张表组合出的所有情况会有错误数。
2.表的连接查询有几种?
答：3种，（1）内连接查询包括隐式内连接和显式内连接
（2）外链接查询包括左外连接和右外链接
（3）子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：查询中嵌套查询，子查询的结果有3种情况，
（1）子查询的结果是单行单列的，子查询可以作为条件，使用运算符去判断。
（2）子查询的结果是多行单列的，子查询可以作为条件，使用运算符in来判断。
（3）子查询的结果是多行多列的，子查询可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚?
答：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功要么同时失败。
提交：当执行没问题，提交事务
回滚：当执行出现问题，回滚事务
5.mysql有几个隔离级别?
答：4个级别;
read uncommitted 读未提交 会产生的问题：脏读，不可重复读，幻读
read committed 读已提交 会产生的问题：不可重复读，幻读
repeatable read 可重复读 会产生的问题：幻读
serializable 串行化
6.数据库并发访问问题都有哪些?
答：脏读：一个事务读取到另一个事务中没有提交的数据。
不可重复读：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作（DML）数据表中的记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 蓝建华    时间: 2019-4-11 21:51
1.什么情况下会用到表连接查询?
答：当需要查询多个表的时候，然后会出现笛卡尔积现象，需要消除多余的数据的时候
2.表的连接查询有几种?
答：内连接
                隐式内连接   select 字段列表 from 表名1 ，表名2 where 条件
        显式内连接   select 字段列表 from 表名1 [inner] join 表名2 no 条件
      外连接
        左外表  select 字段列表 from 表名1 left [outer] join 表名2 no 条件
        右外表  select 字段列表 from 表名1 right [outer] join 表名2 no 条件
      子查询  
       
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：查询中嵌套查询叫做子查询 ，会有三种情况
        单行单列：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
        多行单列：子查询可以作为条件，使用运算符in来判断
        多行多列： 子查询可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚?
答：事务就包含多个业务操作，被事务管理的，一起同时成功执行要么同时执行失败
       提交是再开始事务后如果执行成功，但是没有提交事务那么真实数据将不会修改
       回滚是在执行后发现问题可以使用回滚进行回到开始事务前
5.mysql有几个隔离级别?
答：有四个级别
               read uncommitted：读未提交
        read committed：读已提交
        repeatable read：可重复读
        serializable：串行化
6.数据库并发访问问题都有哪些?
        1. 脏读：一个事务，读取到另一个事务中没有提交的数据
        2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样
        3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 沈松宏    时间: 2019-4-11 21:52
1.什么情况下会用到表连接查询?
消除笛卡尔积
2.表的连接查询有几种?
①内连接查询
        隐式内连接:加上where 条件
        闲式内连接:表1 join表2 on 条件
②外连接
        左外连接 表1 left join表2 on 条件
        查询左边表1的所有数据 及其表1和表2的交集
        右外连接:表1 right join表2 on 条件
③子查询
嵌套在查询语句中的查询语句

       
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
嵌套在查询语句中的查询语句,
        子查询的结果为单列单行 :比较运算符：>、<、=)
        多行单列：使用 in 关键字
    多行多列：放在 from 后面，做为一张表再次查询
4.什么是事务，什么是提交，什么是回滚?
一个包含多个操作步骤的业务.被事务管理,那么这些操作要么同时成功,要么同时失败.
提交 commit
回滚 rollback
5.mysql有几个隔离级别?
读未提交
读一提交
可重复性
串行化
6.数据库并发访问问题都有哪些?
脏读、不可重复读、幻读

---

作者: 王旭艺    时间: 2019-4-11 21:53
1.什么情况下会用到表连接查询?
      当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的

临时表.

2.表的连接查询有几种?
      一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表

FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
     第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和

右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
     第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
      子查询是查询中嵌套查询，称嵌套查询为子查询。
      子查询不同情况
      1. 子查询的结果是单行单列的：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
      2. 子查询的结果是多行单列的：子查询可以作为条件，使用运算符in来判断
      3. 子查询的结果是多行多列的：子查询可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚?
      事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别?
      有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些?
      脏读：一个事务，读取到另一个事务中没有提交的数据
      不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
      幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: omasoo    时间: 2019-4-11 21:54
李伟斌

1.什么情况下会用到表连接查询?
答：当要查询的数据分散在多张表的时候，我们会用到表连接查询；
2.表的连接查询有几种?
答：有三大种，分为内连接查询和外连接查询和子查询，内连接查询分为隐式查询和显式查询两种。外连接查询又分为左外连接和右外连接。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
答：查询中嵌套查询，称嵌套查询为子查询。子查询有三种情况，
a. 子查询的结果是单行单列的：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =。
b.子查询的结果是多行单列的：子查询可以作为条件，使用运算符in来判断。
c.子查询的结果是多行多列的：子查询可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚?
答：事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
      提交：事务的结束语句，当手动开启的事务，执行确定没有问题后必须要使用commit提交对事务进行提交，否则事务显示的只是暂时的数据，只有提交事务后，数据才可以持久保存。
      回滚：当执行过程中出现问题就不会执行而是会回到执行的原点：rollback。
5.mysql有几个隔离级别?
答：有四个隔离级别，
分别是 a. read uncommitted：读未提交会产生的问题：脏读、不可重复读、幻读
           b. read committed：读已提交 （Oracle）会产生的问题：不可重复读、幻读
           c. repeatable read：可重复读 （MySQL默认）会产生的问题：幻读
           d. serializable：串行化可以解决所有的问题
           注意：隔离级别越高，越安全，但效率越低。
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: javawjs    时间: 2019-4-11 21:58
王佳盛
1.什么情况下会用到表连接查询?
当我们查询的数据需要从不同的表中获取到时，就可以用到表连接查询

2.表的连接查询有几种?
隐式内连接：select 字段列表 from 表1 ,表2 where 条件
显示内连接：select 字段列表 from 表1 [inner] join 表2 on 条件
左外连接： select 字段列表 from 左表 left [outer] join 右表 on 条件
右外连接：select 字段列表 from 左表 right [outer] join 右表 on 条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
概念：查询语句嵌套一个查询语句，被嵌套的查询语句就是子查询
结果分类：
单行单列：可以直接作为条件，使用运算符判断
多行单列：可以直接作为条件。使用运算符in进判断
多行多列：子查询可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败；
提交：将开启事务后改变的数据，进行永久保存；
回滚：将数据回档成开启事务前的状态；

5.mysql有几个隔离级别?
读未提交：read uncommitted；
读已提交：read committed；
可重复读：repeatable read；
串行化：serializable；
安全级别从上往下一次增加，但效率逐渐下降；

6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务没有提交的数据；
不可重复读 (虚读)：在同一个事务中，两次读取到的数据不一样；
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改；

---

作者: 黄成龙    时间: 2019-4-11 21:59
1.什么情况下会用到表连接查询
当一个表不能完整的查找到我们所需要的数据时，需要用到表连接查询

2.表的连接查询有几种
内连接查询：
       隐式内连接：使用where条件消除无用的数据
       显示内连接：使用join作为消除无用的数据
外连接查询：
       左外连接：使用关键字left  join 来关联两个表，他会查询左表的说有数据和右表的交集部分
       右外连接：使用关键字right join 来关联两个表，他会查询右表的说有数据和左表的交集部分
子查询：用一条SQL语句的结果作为另外一条语句的条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询是：用一条SQL语句的结果作为另外一条语句的条件
有几种情况：
        单行单列的，直接使用算数运算符使用
        多行单列的，使用运算符in来判断
        多行多列的，可以把查询出来的表作为一个虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚
事务：如果一个包含多个步骤的业务操作，被事物管理,那么这些操作要么同时成功，要么同时失败。
提交：当确认数据正确无误时，提交数据，他会把数据持久化的保存在硬盘中。
回滚：当事务中的SQL语句出现错误的时候，使用回滚语句，可以回滚到事务开启时的状态。

5.mysql有几个隔离级别
隔离级别：
（1）read uncommitted：读未提交
            产生的问题：脏读、不可重复读、幻读
（2）read committed：读已提交 （Oracle）
            产生的问题：不可重复读、幻读
（3）repeatable read：可重复读 （MySQL默认）
            产生的问题：幻读
（4）serializable：串行化
            可以解决所有的问题

6.数据库并发访问问题都有哪些
（1）脏读：一个事务，读取到另一个事务中没有提交的数据
（2） 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
（3） 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: JavaEE06蒋才东    时间: 2019-4-11 21:59
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 唐彬桂    时间: 2019-4-11 22:33

1.什么情况下会用到表连接查询?
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种?
1.内连接查询,
       隐式内连接:使用WHERE条件消除无用的数据
       显示内连接:使用join作为消除无用的数据
2. 外链接查询
       左外连接 使用关键字left join 来关联两个表,他会查询左表的说有数据和右表的交集部分
       右外连接 使用关键字rightjoin 来关联两个表,他会查询右表的说有数据和左表的交集部分
3.子查询
        用一条SQL语句的结果作为另外一条语句的条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
查询中嵌套查询，像Java中的链表结构，被称为子查询
单行单列：作为条件使用，使用运算符判断： > >= < <= =
多行单列：作为条件使用，使用运算符in判断
多行多列：可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交后内容将保存到硬盘中，持久化的保存数据在事务提交前遇到问题可以使用回滚返回事务开始时的值

5.mysql有几个隔离级别?
有read uncommitted、read committed、 repeatable read、serializable 四种

6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提交的数据。
不可重复读：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作数据表中的所有记录，，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 廖艺铭    时间: 2019-4-11 23:05
1.什么情况下会用到表连接查询?
当查询结果在多张不同的表中，就需要在一条 SQL 语句查询多张表

2.表的连接查询有几种?
内连接，外连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：嵌套在查询语句中的查询语句
子查询的结果分为三种：
①子查询的结果是单行单列的：
        子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
②子查询的结果是多行单列的：
        子查询可以作为条件，使用运算符in来判断  in (Select ...)
③子查询的结果是多行多列的：  
        子查询可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务：是将多条sql语句 统一管理 要么同时成功 要么 同时失败
提交：当程序没有问题用commit提交事务，提交后才会同步到数据表中
回滚：出现问题用rollback回滚事务，回滚到事务开启的状态，也可自定义回滚点，异常时回到回滚点

5.mysql有几个隔离级别?
mysql有四个隔离级别：
① read uncommitted：读未提交
②read committed：读已提交
③ repeatable read：可重复读
④ serializable：串行化

6.数据库并发访问问题都有哪些?
存在问题：
①脏读：一个事务，读取到另一个事务中没有提交的数据
②不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样
③幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 苏森鹏    时间: 2019-4-11 23:15
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 叶振鹏    时间: 2019-4-11 23:39

1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        内连接查询：内连接只能查询到两表有交集的信息，如果没有交集，则会被认为错误信息，不会被显示出来；
        外链接查询：查询表的所有数据和该表的交集部分；
        子查询：查询中嵌套查询，嵌套查询为子查询；

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列：当查询结果为单行单列时可直接作为条件，能用运算符进行判断；
                多行单利：当查询结果为多行单列时可以直接作为条件，用 运算符 in 来判断  
                多行多列：当查询结果为多行多列时，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用


4.什么是事务，什么是提交，什么是回滚?
        事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败；
        提交：分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚：是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
        安全级别从上往下一次增加，但效率逐渐下降；

6.数据库并发访问问题都有哪些?
  并发访问有下列三个问题
        脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
        不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
        幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 林奕全    时间: 2019-4-12 00:02
1.什么情况下会用到表连接查询?

在有多张表之间数据存在关联关系的,通过一张表的外键关联另一张表的数据的主键来建立联系,查找想要的数据的时候就要用到表连接.

2.表的连接查询有几种?

内连接:

隐式内连接:select 字段列表 from 表名 where 表名1的列名 关联 表名2的列名  目的是为了消除笛卡尔积冗余数据.

显示内连接:seleect 字段列表 from 表名1 join 表名2 on 条件

外连接:

左外连接: select 字段列表 from 表名1 left join 表名2 on 条件  查询的是左表所有数据以及与右表交集部分。

右外连接:select 字段列表 from 表名1 right join 表名2 on 条件

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?

子查询是查询语句中嵌套另一个查询语句,可以多层嵌套.

分类:

单行单列: 可以使用运算符(> ,= ,<,  >= ,<=)判断作为查询条件.

多行单列:可以使用运算符 IN判断作为查询条件

多行多列:使用第三张虚拟表来作为条件查询



4.什么是事务，什么是提交，什么是回滚?

事务就是 对多条操作 sql语句进行统一管理,要么同时成功,要么同时失败.

事务的4大特征:AICD

A 原子性:是不可分割的最小操作单位,要么同时成功,要么同时失败

I 隔离性:多个事务之间,相互独立

C一致性:事务操作前后,数据的总量不变

D持久性:一旦commit提交事务或者rollback回滚,数据库就会持久化存储数据

提交:commit,事务开启后,如果没有问题,最后必须 手动提交事务,数据才会持久化更新到数据库中

回滚:rollback ,事务开启后,如果操作多条sql语句过程中出现了问题或错误,那么不会提交事务,而是回滚到事务开启的那个阶段.

5.mysql有几个隔离级别?

1)读未提交read uncommitted

2)读已提交 read committed (oracle默认)

3)可重复读 repeatable read (mysql 默认)

4)串行化 serializable

6.数据库并发访问问题都有哪些?

脏读：一个事务，读取到另一个事务中没有提交的数据

不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。

幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 李智梁    时间: 2019-4-12 20:52
1.什么情况下会用到表连接查询
  当一个表不能完整的查找到我们所需要的数据时,需要用到表连接查询
2.表的连接查询有几种
   内连接查询,
       隐式内连接:使用WHERE条件消除无用的数据
       显示内连接:使用join作为消除无用的数据
   外链接查询
       左外连接 使用关键字left join 来关联两个表,他会查询左表的说有数据和右表的交集部分
       右外连接 使用关键字rightjoin 来关联两个表,他会查询右表的说有数据和左表的交集部分
   子查询
        用一条SQL语句的结果作为另外一条语句的条件
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
    用一条SQL语句的结果作为另外一条语句的条件
    查询的结果是单行单列的,直接使用算数运算符使用.
    查询结果是多行单列的,使用运算符in来判断
    查询结果是多行多列的,可以把查询出来的表作为一个虚拟表参与查询.
4.什么是事务，什么是提交，什么是回滚
    如果一个包含多个步骤的业务操作,被事物管理,那么这些操作要么同时成功,要么同时失败,提交就是当确认数据正确
无误时,提交数据,他会把数据持久化的保存在硬盘中.回滚,当事务中的SQL语句出现错误的时候,使用回滚语句,可以回滚
到事务开启时的状态
5.mysql有几个隔离级别
   1. 原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
   2. 持久性：当事务提交或回滚后，数据库会持久化的保存数据。
   3. 隔离性：多个事务之间。相互独立。
   4. 一致性：事务操作前后，数据总量不变
6.数据库并发访问问题都有哪些
   1. 脏读：一个事务，读取到另一个事务中没有提交的数据
   2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
   3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 6期江岳    时间: 2019-4-12 22:30

1.什么情况下会用到表连接查询?
需要查询的数据必须通过多张表才能完全获取所需的数据，这时候需要多表查询。
2.表的连接查询有几种?
内连接查询： 隐式内连接 、显式内连接、 内连接查询
外链接查询：左外连接、右外连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询结果只要是单列，则在 WHERE 后面作为条件
子查询结果只要是多列，则在 FROM 后面作为表进行二次查询
      
4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
当事务执行完后，进行保存的步骤称之为提交
当事务执行失败，将数据库恢复成事务未开始前的样子的步骤称之为回滚
5.mysql有几个隔离级别?
1）读未提交 read uncommitted
2）读已提交 read committed
3）repeatable read 可重复读
4）seriablizable： 串行化
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中未提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 张广发    时间: 2019-4-13 21:14

1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 刘曾铭    时间: 2019-4-13 21:15
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: java基础6期刘伟    时间: 2019-4-13 21:18
1.什么情况下会用到表连接查询

当我们需要查询两个表中的信息的时候，就需要使用多表查询，而多表查询的前提就是表连接。
2.表的连接查询有几种

分为内连接和外连接，其中内连接又分为隐式内连接和显示内连接，外连接分为左外连接和右外连接。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用

子查询：子查询就是把一个查询的结果作为另一个查询的条件，有查询的嵌套，内部的查询称为子查询，子查询需要用括号。
4.什么是事务，什么是提交，什么是回滚

事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交：事务的结束语句，当手动开启的事务，必须要使用提交对事务进行提交，否则事务显示的只是暂时的数据，只有提交事务后，数据才可以持久保存。
回滚：如果事务过程中出现了问题，就需要回滚数据，让数据回到开启事务之前，也是事务结束的一种语句。
5.mysql有几个隔离级别

有4个隔离级别，分别是：
1. read uncommitted：读未提交
产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）
产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）
产生的问题：幻读
4. serializable：串行化
可以解决所有的问题

6.数据库并发访问问题都有哪些

脏读：一个事务，读取到另一个事务中没有提交的数据。
不可重复读：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作数据表中的所有记录，，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: 魏政    时间: 2019-4-13 21:36
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 魏政    时间: 2019-4-13 21:37
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 卢春旭    时间: 2019-4-13 21:50
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.
2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;
4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;
5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;
6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 小翔vvvv    时间: 2019-4-13 21:54
叶凌青：

1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: chenopen    时间: 2019-4-14 21:54
陈开明：


1.什么情况下会用到表连接查询?
需要查询的字段在多张表中，就需要用到表连接查询
2.表的连接查询有几种?
表查询分为内连接和外连接查询。
内连接分为隐式内连接和显示内连接。
外连接分为左外连接和右外连接。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：一个查询的结果作为另一个查询的条件，有查询的嵌套，内部的查询称为子查询。
子查询结果是单行单列，在where后面作为条件，使用比较运算符。
子查询结果是多行单列，结果类似一个数组，父查询使用IN运算符。
子查询结果是多行多列，在FORM后面作为表。
4.什么是事务，什么是提交，什么是回滚?
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交是让事务执行的SQL语句结果永久化保存，而不是仅仅在内存中看到结果。
回滚是指当事务的SQL语句有执行失败的时候，将数据保持在回滚点的状态。
5.mysql有几个隔离级别?
4个隔离级别，分别为：
1、read uncommitted
2、read committed
3、repeatable read
4、serializable
隔离级别越高，性能越差，安全性越高
6.数据库并发访问问题都有哪些?
脏读：一个事务，读取到另一个事务中没有提及的数据
不可重复读：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 陈鉴    时间: 2019-4-15 09:34
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

作者: 龚荣章    时间: 2019-4-16 20:23

1.什么是数据库连接池？
答：
        一个容器，用来存放数据库连接对象的容器；

2.使用数据库连接池对我们访问数据库有什么好处？
答：
        好处：
                节省资源；可以节省创建和销毁数据库连接对象的资源，在关闭对象时，并没有进行销毁，而是归还连接池；
                用户访问高效：用户访问时不需要创建对象，在初始化容器时，会自动创建一些对象等待使用；

3.JDBCTemplate的作用？
答：
        对JDBC进行简单的封装，简化了代码的书写，提高了编写效率；

4.请谈谈你对这两天学的工具类封装思想的理解？
答：
        将一些重复度高、繁琐的代码封装成工具类，当要使用时直接调用相应的方法即可，简化的代码的书写，提高了书写的效率，也节省了代码占用的内存；

---

作者: 龚荣章    时间: 2019-4-16 20:23
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 钟扬辉    时间: 2019-4-16 21:13
1.什么情况下会用到表连接查询?
当查询结果在多张不同的表中，就需要在一条 SQL 语句查询多张表

2.表的连接查询有几种?
内连接，外连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
子查询：嵌套在查询语句中的查询语句
子查询的结果分为三种：
①子查询的结果是单行单列的：
        子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
②子查询的结果是多行单列的：
        子查询可以作为条件，使用运算符in来判断  in (Select ...)
③子查询的结果是多行多列的：  
        子查询可以作为一张虚拟表参与查询

4.什么是事务，什么是提交，什么是回滚?
事务：是将多条sql语句 统一管理 要么同时成功 要么 同时失败
提交：当程序没有问题用commit提交事务，提交后才会同步到数据表中
回滚：出现问题用rollback回滚事务，回滚到事务开启的状态，也可自定义回滚点，异常时回到回滚点

5.mysql有几个隔离级别?
mysql有四个隔离级别：
① read uncommitted：读未提交
②read committed：读已提交
③ repeatable read：可重复读
④ serializable：串行化

6.数据库并发访问问题都有哪些?
存在问题：
①脏读：一个事务，读取到另一个事务中没有提交的数据
②不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样
③幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

---

作者: LIUXIAOMING    时间: 2019-4-19 18:45

1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: 卢勇炜    时间: 2019-4-19 20:06
1.什么情况下会用到表连接查询?
        当查询的数据位于多张不同的表中或者自查，无法在一张表内查询到所有数据 这时候会使用到表连接查询,

2.表的连接查询有几种?
        1,内连接查询 包含 隐式内连接 显式内连接
        2,外连接查询 包含 左外连接 右外连接
        3.子查询 子表等同于一张临时创建的表

3.什么是子查询，子查询的结果有几种情况，分别怎么使用?
        子查询的概念：
                1,一个查询的结果做为另一个查询的条件
                2,有查询的嵌套，内部的查询称为子查询
                3,子查询要使用括号
        子查询接口有三种
                单行单列 使用方法在where后作为条件 调用父查询使用比较运算符来比较子查询的值
                多行单利 调用父查询使用IN运算符来比较子查询的值
                多行多列 结果只要是多列，肯定在 FROM 后面作为虚拟表 作为虚拟表需要取别名 内部的SELECT值也需要取别名才能调用

4.什么是事务，什么是提交，什么是回滚?
        事务是将多条sql语句 统一管理 如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败
                好比是java用&&连接在一起的boolean值只要一个出现
        提交分别有手动提交事务和自动提交事务当事务全部成功后可以执行提交事务事务提交才表示事务中语句被永久化保存(保存到硬盘中而不是在内存中)
        回滚是当事务中有SQL语句失败了后执行回滚回滚值事务前的状态

5.mysql有几个隔离级别?
        1隔离级别 read uncommitted (读未提交)会出现 脏读 不可重复度 幻读
        2隔离级别 read committed   (读已提交)会出现 不可重复度 幻读
        3隔离级别 repeatable read  (可重复读)会出现 幻读
        4隔离级别 serializable     (串行化)  脏读 不可重复度 幻读 均不会出现
6.数据库并发访问问题都有哪些?
并发访问有下列三个问题
脏读:一个事务读取到了另一个事务中尚未提交的数据,当未提交的数据回滚了前面读取到的事务是不准确的
不可重复度:一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，是事务 update 时引发的问题
幻读:一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，这是 insert 或 delete 时引发的问题

---

作者: Wyt1935    时间: 2019-4-20 11:27
1.什么情况下会用到表连接查询
当我们要查询的数据在不同的表中,这时候就需要同时查询多个表,将我们要的一列或多列数据取出组合成一个我们需要的临时表.

2.表的连接查询有几种
有三种连接查询方式,
第一种是内连接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示。又分为隐式内连接SELECT  字段列表 FROM  表名列表 WHERE ...和显式内连接 SELECT  字段列表 FROM  左表 [INNER] JOIN  右表 ON  条件;
第二种是外链接查询,用左边表的记录去匹配右边表的记录，如果符合条件的则显示；否则，显示 NULL   又分为左连接和右连接,SELECT  字段名 FROM  左表 LEFT [OUTER] JOIN  右表 ON
第三种是子查询,一个查询的结果做为另一个查询的条件或临时列表,

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询,一个查询的结果做为另一个查询的条件或临时列表, 又分为三种情况, 子查询的结果是单行单列 ,单列多行, 多行多列.
单行单列:在where后面作为条件使用,SELECT  查询字段 FROM  表 WHERE  字段= （子查询）;
单列多行:结果集类似于一个数组，父查询使用 IN 运算符,SELECT  查询字段 FROM  表 WHERE  字段 IN  （子查询）;
多行多列:在From后作为临时表使用,SELECT  查询字段 FROM  （子查询）  表别名 WHERE  条件;

4.什么是事务，什么是提交，什么是回滚
事务是一组操作包含一个或多个步骤,这组操作被事务管理,要么同时成功或者同时失败;
提交时事务操作成功,将操作后的数据永久保存在硬盘中;
回滚是事务操作过程中,遇到错误,将数据回滚到事务开始的地方,数据变化为最开始的时候,并也永久保存在硬盘中;

5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2