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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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中。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

黄志斌：
1.什么情况下会用到表连接查询
  当一个表不能完整的查找到我们所需要的数据时,需要用到表连接查询

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

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

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

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

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

1.什么情况下会用到表连接查询?
数据分散在多张表,需要要到其他表中的数据是需要用到表连接查询

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

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

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

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

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

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)数据中所有记录，另一个事务添加了一条数据，则第一个
        事务查询不到自己的修改。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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. 幻读：一个事务操作数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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）数据表中的记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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.数据库并发访问问题都有哪些?
脏读、不可重复读、幻读

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

李伟斌

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

王佳盛
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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改；

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。