黑马程序员技术交流社区

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

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

作者: lj478360767 时间: 2019-1-12 19: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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 陈彬 时间: 2019-1-12 20:01
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-1-12 20:22
1.什么情况下会用到表连接查询
一个表的内容无法满足我们的需求的时候需要从其他表获取数据会用到表连接查询
2.表的连接查询有几种
内连接查询：隐式内连接使用where清除无用数据；显示内连接inner join on
外连接查询：左外连接left outer join on查询左表所有数据以其交集部分；右外连接：right outer join on 查询右表所有数据以及其交集部分
子查询：查询中嵌套查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，像Java中的链表结构，被称为子查询
单行单列：作为条件使用，使用运算符判断： > >= < <= =
多行单列：作为条件使用，使用运算符in判断
多行多列：可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交后内容将保存到硬盘中，持久化的保存数据
在事务提交前遇到问题可以使用回滚返回事务开始时的值
5.mysql有几个隔离级别
read uncommitted：读未提交
read committed：读已提交（Oracle）
repeatable read：可重复读（MySQL默认）
serializable：串行化
6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 陈佳鹏 时间: 2019-1-12 20:57
1.查询的数据在不同且具有一定联系的表中时会用到表连接查询。
2.内连接查询，外连接查询和子查询三种。
3.查询中嵌套查询，嵌套的查询就是子查询；子查询的结果为单行单列时可以直接作为判断结果，使用运算符判断，结果为单列多行时，作为判断条件时用in（集合）判断，多行多列时，子查询作为一张虚拟表参与查询。
4.如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。手动开启一个事务，当运行结果和预期结果一样时可以执行提交，完成数据的增删改，当运行结果和预期结果不一样时可以执行回滚，将数据还原回执行事务前。
5.MySQL有4个隔离级别，1. read uncommitted：读未提交
* 产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交（Oracle）
* 产生的问题：不可重复读、幻读
3. repeatable read：可重复读（MySQL默认）
* 产生的问题：幻读
4. serializable：串行化
* 可以解决所有的问题
6.脏读、不可重复读、幻读。

作者: 赖熙蒙 时间: 2019-1-12 21:01

1.什么情况下会用到表连接查询
答：当需要同时查询多张表的内容时，就会用到表连接查询。

2.表的连接查询有几种
答：表的连接查询分为内连接查询和外连接查询两种。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：子查询指的是将某条查询语句当做另一条查询语句的条件或者虚拟表来参与查询，也就是在查询中嵌套查询。
子查询的结果有三种：单行单列、多行单列、多行多列。
单行单列：子查询可以作为条件，使用运算符去判断。运算符： > >= < <= =。
多行单列：子查询可以作为条件，使用运算符in来判断。
多行多列：子查询可以作为一张虚拟表参与查询。

4.什么是事务，什么是提交，什么是回滚
答：事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交：当事务执行没有问题时，执行提交动作。提交包括自动提交和手动提交两种方式。
回滚：当事务执行出现问题时，执行回滚动作。回滚能够使数据回到事务执行前的样子。

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

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

作者: Chidori 时间: 2019-1-12 21:01

1.什么情况下会用到表连接查询
当需要查询的信息，分跨不同表格，又想让想要的信息汇总在一起时，就需要用到多表查询，方便我们阅读
2.表的连接查询有几种
内连接：隐式内连接，和显式内连接
外链接：左外链接和右外链接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
只查询有三种情况
子查询的结果是单列的，子查询可以作为条件，使用运算符来判断
子查询结果是多行多单的，子查询可以作为条件，使用in赖判断
子查询结果是多行多列的，子查询可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务所管理，那么这些操作要么同时成功，要么同时失败
提交就是数据持久化保存在数据库中，提交又分为手动提交，自动提交
回滚就是如果被事务所管理的操作出现错误了，那么程序会返回原点，数据恢复事务执行前的样子
5.mysql有几个隔离级别
有read uncommitted、read committed、 repeatable read、serializable 四种
6.数据库并发访问问题都有哪些
容易产生脏读、虚读和幻读四种

作者: 杨鑫棋 时间: 2019-1-12 21:04

1.什么情况下会用到表连接查询

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

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

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

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

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

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

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

作者: 赵烈刚 时间: 2019-1-12 21:06

1.什么情况下会用到表连接查询
需要查找两张表同时存在的数据，使用内连接查询;
需要查找两张表中一张表存在，另一张表不存在的时候使用左外连接或右外连接接;
2.表的连接查询有几种
表连接查询分为内连接查询丶外连接查询丶子查询;
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
类似于嵌套for循环,也就是查询中嵌套查询;
分为3种情况;
单行单列:子查询作为条件,可以使用运算符>丶<丶>=丶<=丶=;
多行单列:子查询作为条件,可以使用in进行判断;
多行多列:子查询作为一张虚拟表参与查询;
4.什么是事务，什么是提交，什么是回滚
事务内的操作要么同时成功,要么同时失败;
如果执行没有问题就会提交事务;
当执行过程中出现问题的时候,就不会执行而是会回到执行的原点;
5.mysql有几个隔离级别
有4个隔离级别;
分别是:1).read uncommitted：读未提交
         2). read committed：读已提交（Oracle默认）
         3). repeatable read：可重复读（MySQL默认）
         4). serializable：串行化
隔离级别从小到大安全性越来越高，但是效率会越来越低
6.数据库并发访问问题都有哪些
脏读丶不可重复读丶幻读

作者: Wujainwei 时间: 2019-1-12 21:15
1.什么情况下会用到表连接查询
需要查询的内容分别存在于多个表时
2.表的连接查询有几种
三种,内连接查询(显示和隐式);外链接查询(左外链接和右外链接);子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询就是一个查询的结果做为另一个查询的条件或临时列表. 分为三种情况:单行单列(where后面作为条件判断使用),单行多列(结果相当于一个数组,可以用in进行数据筛选),多行多列(可以作为一个临时表来使用)
4.什么是事务，什么是提交，什么是回滚
事务就是指一组操作包含一个或多个操作,如果这组操作被事务管理,那结果要么同时被成功执行,要么全部执行失败
提交,将当前临时数据永久的保存进内存当中.
回滚, 数据库回到事务开启前的状态
5.mysql有几个隔离级别
有4个隔离级别,读未提交,读已提交,可重复读,串行化,mysql中默认的级别是可重复读;
6.数据库并发访问问题都有哪些
脏读,不可重复读(虚读),幻读

作者: 苏志祥 时间: 2019-1-12 21:17

1.什么情况下会用到表连接查询
当需求的数据在不同的表中，我们将两张表组合成新表抽取我们需要的列数据。

2.表的连接查询有几种
内连接查询；外连接查询；子查询

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

4.什么是事务，什么是提交，什么是回滚
事务：对一组sql数据操作的时候，对这组数据的管理，要嘛同时成功要嘛同时失败。
提交：commit ,把事务的数据永久写进表保存。
回滚：rollback:将数据返回到开始事务的始点（start transaction），永久保存到数据表中。

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

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

作者: 陈益源 时间: 2019-1-12 21:32
本帖最后由陈益源于 2019-1-13 00:19 编辑

1.什么情况下会用到表连接查询
需要查询内容在多张不同的表中

2.表的连接查询有几种
内连接：
隐式内连接：select 字段名 from 表1，表2 where 去除重复数据条件及筛选条件；
显式内连接：select 字段名 from 表1 join 表2 on 去除重复数据条件 where 筛选条件
外连接：
左外连接：保留左表信息，并取左表和右表的交集信息；
右外连接：保留右表信息，并取右表和左表的交集信息

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

4.什么是事务，什么是提交，什么是回滚
事务：就是一组包含多个步骤的业务操作，被事务管理，那么这些步骤要么同时成功，或者同时失败；
提交：commit，如果一组被事务管理的业务操作，运行成功，那么需要手动执行提交操作，对数据进行持久保存；
回滚：rollback，如果一组被事务管理的业务操作，中途运行失败，那么需要执行回滚操作，恢复到开启事务前的数据。

5.mysql有几个隔离级别
mysql有4个隔离级别：
read uncommitted:读未提交，出现的问题脏读、不可重复读、幻读
read committed:读已提交，出现的问题不可重复读、幻读
repeatable read:可重复读（Mysql默认），出现的问题幻读
serializable:串行化，可以解决所有问题
隔离级别越高，安全性越高，但是效率也越低

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

作者: 陈辉阳 时间: 2019-1-12 21:39

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

2.表的连接查询有几种
内连接查询；外连接查询；子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询就是一个查询的结果做为另一个查询的条件或临时列表. 分为三种情况:单行单列(where后面作为条件判断使用),单行多列(结果相当于一个数组,可以用in进行数据筛选),多行多列(可以作为一个临时表来使用)
4.什么是事务，什么是提交，什么是回滚
事务就是指一组操作包含一个或多个操作,如果这组操作被事务管理,那结果要么同时被成功执行,要么全部执行失败
提交,将当前临时数据永久的保存进内存当中.
回滚, 数据库回到事务开启前的状态

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

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

作者: 陈基林 时间: 2019-1-12 21:44
1.什么情况下会用到表连接查询当想要查询的信息在多个表中的时候就需要用到表连接查询。
2.表的连接查询有几种
大的方面分为内连接查询和外连接查询，然后内连接查询又分为隐式内连接和显式内连接，隐式内连接用where限定去消除无用的笛卡尔积信息，而显式内连接用关键字 [inner] join on 来消除无用的笛卡尔积信息。外连接分为左外连接和右外连接，左外连接是保留左表的所有信息和交集信息，右外连接是保留右表的所有信息和交集信息。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询的概念有：1、一个查询的结果作为另一个查询的条件。2、有查询的嵌套，内部的查询称为子查询。3、子查询要使用括号
子查询的结果有3种情况，1、单行单列 2、多行单列 3、多行多列。前面两个查询的结果可以作为另一个查询的条件，而多行多列这种情况是作为一张虚表跟其他的表一起参与查询，即嵌套的查询。
4.什么是事务，什么是提交，什么是回滚
事务是在实际的开发过程中一个业务操作。事务执行是一个整体，所有的sql语句要么都执行成功，不然只要一句出现异常则所有的sql语句都要回滚，整个业务就执行失败。
提交就是在这个事务执行成功之后将这个操作得到的结果保存。回滚是事务执行失败将数据恢复到执行这个事务之前。
5.mysql有几个隔离级别
隔离级别有4个，1、read uncommit，这个级别安全性最低，会导致的问题有脏读、不可重复读、幻读。2、read commit，这个隔离级别可以解决脏读这个问题，但是还是会有后面2个问题。3、repeatable read 这个隔离级别可以解决不可重复读的问题。 4、serializable，串行化，可以解决所有问题。隔离级别越高，安全性越高，但是相对的效率也就越低。因此要选择合适的隔离级别来使用。
6.数据库并发访问问题都有哪些

1、丢失更新，即幻读。
2、不可重复读。当两个数据读取某个数据后，另一事务执行了对该数据的更新，当前一事务再次读取该数据（希望与第一次读取的是相同的值）时，得到的数据与前一次的不一样，这是由于第一次读取数据后，事务B对其做了修改，导致再次读取数据时与第一次读取的数据不相同。
3、脏读，当一个事务修改某个数据后，另一事务对该数据进行了读取，由于某种原因前一事务撤销了对改数据的修改，即将修改过的数据恢复原值，那么后一事务读到的数据与数据可得不一致，称之为读脏数据

作者: 杨馥榕 时间: 2019-1-12 21:45
1.什么情况下会用到表连接查询
答：当我们需要查询多个表里的信息的时候，需要用到表连接查询。
2.表的连接查询有几种
答：<1>:显式内连接，<2>：外链接查询，<3>:子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：查询中嵌套查询，称嵌套查询为子查询；
3种查询结果
<1>：单行单列的：*子查询可以作为条件，使用运算符去判断。运算符：>>= < <= =。
<2>:多行单列的：*子查询可以作为条件，使用运算符in来判断
<3>:多行多列的：*子查询可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚
答：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
当业务操作被事务管理，操作成功了就会保存数据叫提交。
当业务操作被事务管理，操作失败了就会返回原来数据不会进行保存称为回滚。
5.mysql有几个隔离级别
答：4种级别， 1. read uncommitted：读未提交
* 产生的问题：脏读、不可重复读、幻读
  2. read committed：读已提交（Oracle）
* 产生的问题：不可重复读、幻读
  3. repeatable read：可重复读（MySQL默认）
* 产生的问题：幻读
  4. serializable：串行化
* 可以解决所有的问题
6.数据库并发访问问题都有哪些
答：1. 脏读：一个事务，读取到另一个事务中没有提交的数据
   2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
   3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: zhuyiming 时间: 2019-1-12 21:45
1.什么情况下会用到表连接查询
只要进行多表查询就需要用到表连接查询
---------------------------------------------------------------------------
2.表的连接查询有几种
分别是:
内连接查询:
1.隐式内连接
2.显式内连接
外连接查询:
1.左外连接
2.右外连接
3.子查询
---------------------------------------------------------------------------
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
1.子查询的结果是单行单列的:
子查询可以作为条件，使用运算符去判断。运算符： > >= < <= =
2.子查询的结果是多行单列的:
子查询可以作为条件，使用运算符in来判断
3.子查询的结果是多行多列的:
子查询可以作为一张虚拟表参与查询
---------------------------------------------------------------------------
4.什么是事务，什么是提交，什么是回滚
事物:
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交:
事务提交的两种方式：
1.自动提交：
一条DML(增删改)语句会自动提交一次事务。mysql就是自动提交的
2.手动提交：
* 需要先开启事务，再提交
回滚:
当执行失败的时候,回返回到程序的起始点
---------------------------------------------------------------------------
5.mysql有几个隔离级别
1. read uncommitted：读未提交
产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交（Oracle）
产生的问题：不可重复读、幻读
3. repeatable read：可重复读（MySQL默认）
产生的问题：幻读
4. serializable：串行化
可以解决所有的问题
---------------------------------------------------------------------------
6.数据库并发访问问题都有哪些
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 许晓明 时间: 2019-1-12 21:46
1.什么情况下会用到表连接查询
答：当进行多表查询的时候，因为使用笛卡尔积的方式查看会出现很多无用的数据，所以需要使用表连接查询的方式去除这些无用的数据，拿到我们需要的数据。

2.表的连接查询有几种
答：表的连接查询有2种，分别为内连接和外连接。
其中内连接可以分为隐式内连接和显式内连接，两者的差异主要是格式上的差异，显示内连接可以明显的区别筛选条件和区分无用数据的条件，隐式内连接则省略了。
外连接可以分为左外连接和右外连接，左外连接是显示左表的整体和左右表的交集，右外连接是显示右表的整体和左右表的交集。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：子查询是在查询中嵌套查询，这个嵌套的查询就是子查询
子查询的结果有三种情况：
a.子查询的结果是单行单列，子查询的结果可以作为条件，使用运算符（>,<,=，！=）去判断，这个情况较常使用。
b.子查询的结果是多行单列，子查询的结果可以作为条件，使用运算符in来判断；
c.子查询的结果是多行多列，子查询的结果可以作为一个虚拟表参与查询，将查询到的新表直接作为多表查询的其中一个进行查询操作；

4.什么是事务，什么是提交，什么是回滚
答：一个包括多个步骤的业务操作被事务管理，这些操作要么一起操作成功，要么一起操作失败。
提交指的是在开启事务后，事务中的操作会先保存在虚拟表中，当执行提交操作以后才会把数据写入数据库中。
回滚指的是当开启事务以后，在业务的执行过程中出现异常，通过回滚可以把数据返回事务开启前的状态。

5.mysql有几个隔离级别
答：有4个隔离等级，分别为read-uncommitted（读未提交），read-committed（读已提交），repeatable read（可重复读），seralizable（串行读）。
以上隔离等级由左向右，越来越大，安全性越来越高，但是效率越来越低。
在read-uncommitted会出现脏读，不可重复读，幻读的情况，read-committed会出现不可重复读和幻读的情况，repeatable read会出现幻读的情况。
seralizable不会出现问题，由于是使用锁机制把表锁起来的，所以效率最低，安全性最高。

6.数据库并发访问问题都有哪些
答：有3种：不可重复读（虚读），幻读，脏读。
脏读指的是一个事务可以读取到另一个事务还未提交的数据。可以通过read-committed等以上隔离级别来避免这个问题的发生。
不可重复读指的是同一个事务两次读取的数据不一致。可以通过repeatable等以上隔离级别来避免这个问题的发生。
幻读指的是一个事务进行操作DML操作的时候，另一个事务进行增加数据的操作，第一个事务会查询到一个自己未曾操作过的数据。只能通过seralizable这个隔离级别来避免这个问题。

作者: 董志超Eric 时间: 2019-1-12 21:47
1.什么情况下会用到表连接查询
答：查询结果的需求，涉及多个表的数据，并且，这些表之间有主外键联系或逻辑联系。
2.表的连接查询有几种
答：分为三类
（1）内连接查询（隐式内连接查询、显示内连接查询）
格式：隐式 select 查询内容 from 表1，表2 where 查询条件
显示 select 查询内容 from 表1 [inner ]join 表2 on 去重复条件 where 查询条件
（2）外连接查询（左外连接查询、右外连接查询）
格式：左外连接 select 查询内容 from 表1 left [outer] join 表2 on 去重复条件 where查询条件
右外连接 select 查询内容 from 表1 right[outer] join 表2 on 去重复条件 where查询条件
（3）子连接查询嵌套查询。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：三种情况
（1）子查询结果是单行单列时，可以使用<、>、=等运算符进行条件判断
（2）子查询结果是多行单列时，可以使用运算符in进行条件判断
（3）子查询结果是多行多列时，可以将查询结果作为一张虚拟表参与查询。

4.什么是事务，什么是提交，什么是回滚
答：事务transaction，就是一系列业务操作被事务管理。
那么这一系列操作要么同时成功，要么同时失败。
提交commit，全部成功时。
回滚rollback，全部失败时。

5.mysql有几个隔离级别
答：3个隔离级别：
1.read uncommitted 读取未提交
2.read committed 读取已提交
3.repeatable read 可重复读
mysql默认是可重复读隔离级别。

6.数据库并发访问问题都有哪些
答：由于隔离级别不够，并发访问数据库会发生：
1.脏读，一个事务读取到了另一个事务还没有提交的事务
2.不可重复读，一个事务中，连续两次读取的内容不一致。
（updata操作时引起）
3.幻读，一个事务中两次读取的数据的数量不一致。
（insert和delete操作时引起）

作者: 骆颖权 时间: 2019-1-12 21:47

1.什么情况下会用到表连接查询
当我们查询数据的时候需要同时用到多张表的时候，就要用到表连接查询。
2.表的连接查询有几种
1.内查询：显式内连接和隐式内连接
2.外查询：左外查询和右外查询
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-1-12 21:49

1.什么情况下会用到表连接查询
答：当要查询的信息不在一张表里的情况下，并且两张表有主键和外键的关系

2.表的连接查询有几种
答：表的连接查询有三种，内连接（隐式内连接，显式内连接），
外连接（左外连接，右外连接），子连接

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：两种查询嵌套起来就是子查询，子查询的结果有三种，单行单列，单行多列
和多行多列

4.什么是事务，什么是提交，什么是回滚
答：事物就是在sql语言执行时，当有错误的时候，语句不会执行下去，会根据
rollback语句回滚到语句没开始执行之前，可以保证一些情况的安全性，比如
银行转账例子，当语句没有出错的时候，会根据commit语句提交结果，完成
sql执行

5.mysql有几个隔离级别1.read uncommitted：读未提交 2. read committed：读已提交（Oracle默认）3. repeatable read：可重复读（MySQL默认）4 serializable：串行化隔离级别从小到大安全性越来越高，但是效率会越来越低

6.数据库并发访问问题都有哪些
脏读丶不可重复读丶幻读

作者: 吴少华 时间: 2019-1-12 21:49
1.什么情况下会用到表连接查询
当我们查询的数据涉及到多张表内的数据时或者查询同一张表内相关关系的数据，就会用到表连接查询
2.表的连接查询有几种
内连接查询，外连接查询，子查询3种
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
将一种查询结果数据整合当做一张表的嵌套查询方式为子查询
结果有单行单列，单行多列，多行多列3种
4.什么是事务，什么是提交，什么是回滚
包含多个或者一个sql语句，这些sql语句要么同时成功要么同时失败，将这些操作整合成一个整体就是事务
commit 提交就是缓存的数据不管失败与否都把成功的sql语句持久性的保存。
rollback 或滚就是出现异常没有成功，将缓存清空，将数据退回到最初设置开始点或者保存点的地方
5.mysql有几个隔离级别
read uncommited(阅读未提交的缓存数据）
read commited(阅读已提交的缓存数据）
repeatable read(可重复读）当两张表有一方数据没提交，未进行数据操作的表读取不到数据
serializable（串行化）安全性最高，在操作数据的表没提交之前，另一张表被锁定不能进行操作。
隔离级别越高，性能越差，安全性越高
6.数据库并发访问问题都有哪些
1.脏读，另一张表读取到操作数据表的事务内未提交的缓存内容
2.不可重复读，另一张表事务表提交前和提交完读取俩次的结果来自操作数据表的未提交缓存数据和提交缓存数据的俩次内容，内容结果不同。
3.幻读，另一张表事务表同一个事务内读取俩次的结果来自操作数据表的未提交缓存数据和提交缓存数据的俩次内容，内容结果不同。

作者: 黄嘉宏 时间: 2019-1-12 21:50
1.什么情况下会用到表连接查询
所要查询的数据存在于多张不同的表中。
2.表的连接查询有几种
内连接查询和外连接查询，内连接查询分为隐式内连接和显式内连接，外连接分为左外连接和右外连接。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
把一个查询的结果作为另一个查询的嵌套条件。子查询的结果有单行单列，多行单列，多行多列。
得出的结果如果是单行单列，那么一般是作为一个值对条件进行判断得出结果。
得出的结果如果是多行单列，相当于一个数组去进行判断，使用IN运算符。
得出的结果如果是多行多列，则放在FROM后作为表去判断。
4.什么是事务，什么是提交，什么是回滚
事务中所有的SQL语句执行的话必须一起成功，或者一起失败。
当事务中的语句都执行成功，使用commit提交事务，以保存数据。
当事务中的语句只要有一条执行失败，那么该事务就会使用回滚事务rollback回到开启事务的起点，
在start transaction位置。
5.mysql有几个隔离级别
mysql有4个隔离级别，从级别低到高分为：
1读未提交 read uncommitted，会出现脏读，不可重复读，幻读问题
2读已提交 read committed，会出现不可重复读，幻读问题
3可重复读 repeatable read，会出现幻读问题
4串行化 serializable ，不会出现问题
隔离级别越高，性能越差，安全性越高
6.数据库并发访问问题都有哪些
脏读，一个事务读取到了另一事务中尚未提交的数据。
不可重复读，一个事务中两次读取的数据内容不一致，要求的是一个事务中多次读取时数据是一致的，
这是事务update时引发的问题。
幻读，一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致的，
这是insert或delete时引发的问题。

作者: 吴洪标 时间: 2019-1-12 21:50
本帖最后由吴洪标于 2019-1-12 22:45 编辑

1.什么情况下会用到表连接查询
当需要查询的数据被存储在多张表中时，需要同时查询多张表，此时会用到表连接查询。

2.表的连接查询有几种
内连接：
1）隐式内连接：使用where条件建立连接，消除笛卡尔积中的无用数据；
2）显示内连接：使用关键字[inner] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表名1 [inner] join 表名2 on 条件。
外连接：
1）左外连接：使用关键字left [outer] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表1 left [outer] join 表2 on 条件；
2）右外连接：使用关键字right [outer] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表1 right [outer] join 表2 on 条件。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询是指在一个查询语句中嵌套了另一个查询语句：
1）子查询的结果是单行单列时，可以将子查询的结果作为条件，使用运算符进行判断；
2）子查询的结果是多行单列时，可以将子查询的结果作为条件，使用关键字in进行判断；
3）子查询的结果是多行多列时，可以将结果当成是一张虚表去参与查询。

4.什么是事务，什么是提交，什么是回滚
事务是指sql语句中的一个逻辑执行单位，在一个事务中执行多个sql语句，这些语句要么被同时成功执行，要么同时不被执行。
如果事务中的语句都成功执行，则commit语句会把执行结果永久化保存，这个操作也叫提交。
如果事务中的存在执行失败的语句，则rollback语句会将数据库恢复到事务开始的状态，这个操作也叫回滚。

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

6.数据库并发访问问题都有哪些
1）脏读：一个事务读取到另一个事务未提交的数据；
2）不可重复读（虚读）：一个事务中，前后读到的数据不一致，如同一个记录的balance，第一次读为100，第二次读为200，前后不一致；
3）幻读：一个事务中，针对某一范围（表全体记录，或者某一具体范围如1000-5000范围内的salary）的记录查询，前后查询的记录数量不一致，如第一次查询有5条记录，第二次查询有6条记录。造成幻读的原因是因为在这个事务的多次读取期间，另一个事务向同一张表插入了数据，造成记录数量的变化。

作者: 周章强 时间: 2019-1-12 21:52

1.什么情况下会用到表连接查询
在需要进行多表查询的情况下，即需要的数据在多个表格里面的时候。

2.表的连接查询有几种
(1)内连接查询：
隐式内连接：使用where关键字，使用where条件消除无用数据。
显式内连接：使用inner join关键字，使用join条件消除无用数据。
(2)外连接查询：
左外连接：使用left outer join 关键字，查询的是左表所有数据以及其交集部分。
右外连接：使用right outer join关键字，查询的是右表所有数据以及其交集部分。
(3)子连接查询：
查询中嵌套查询，称嵌套查询为子查询。即将查询到的内容作为条件再次查询。

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

4.什么是事务，什么是提交，什么是回滚
事务：多个运行步骤的集合。可以理解成将这些步骤连接成&&关系，即只要有一个步骤出错，则所有的步骤都失败。

提交：代码在运行之后的结果并没有直接改变库的数据，需要提交之后库的数据才会改变。

回滚：将之前运行的代码结果放弃，库的数据保持运行之前的结果。

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

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

作者: Java中的莫Q哇啦 时间: 2019-1-12 21:56
1.什么情况下会用到表连接查询
当需要多查询多个有连接关系的表之间的数据时，要用到表连接查询。

2.表的连接查询有几种
隐式内连接查询，显示内连接查询，左外链接查询，右外链接查询，子查询。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询就是查询里面嵌套一个查询，也可以理解为链式的方式查询；有三种，第一种是单行单列查询，子查询可以作为条件，使用运算符去判断。第二种是多行单列，子查询作为条件，使用运算符in来判断；第三种是多行多列，子查询作为一张虚拟表参与查询。

4.什么是事务，什么是提交，什么是回滚
事务就是多个sql语句要么同时执行，要么同时不执行；提交就是在开启事务后，把执行后的sql语句永久性的保存起来；
回滚就是把sql语句返回到事务开启的地方，在这区间内执行的sql语句不会保存。

5.mysql有几个隔离级别
有四种隔离级别：第一种是最低级别的uncommit，效率最高，但是会出现脏读，不可重复读，幻读等问题发生；
第二级别commit，解决了脏读的问题，但是无法解决另外两个问题；第三级别解决了脏读和不可重复读的问题，
但是会出现幻读的问题；最高级别也是效率最低的隔离方式，解决了所有的问题。

6.数据库并发访问问题都有哪些
并发访问会出现脏读，不可重复读，幻读等三个情况。

----------------黄成成

作者: 黄毅 时间: 2019-1-12 21:57

1.什么情况下会用到表连接查询
一张表中没有所有的数据，需要通过多张表的关系查找数据的时候用到表连接查询
2.表的连接查询有几种
隐式内连接查询
显示内连接查询
内连接查询
左外连接查询
右外连接查询
子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询内嵌套查询 3种
当子查询的结果是单行单列的时候，可以作为条件使用运算符去判断
当子查询的结果是多行单列的时候，可以作为条件用用运算符in来判断
当子查询的结果是多行多列的时候，可以作为一张虚拟表进行查询
4.什么是事务，什么是提交，什么是回滚
事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交：事务成功后，更新数值
回滚：当事务失败是，数据恢复到操作前的数值
5.mysql有几个隔离级别
read uncommitted 读未提交
read committed 读已提交
repeatable read 可重复读
serializable 串行化
6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
虚读：在同一个事务中，两次读取到的数据不一样
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 王宇鹏 时间: 2019-1-12 21:57
1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系

2.表的连接查询有几种
内连接查询
外链接查询
子查询

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中再添加查询语句成为子查询。子查询的结果可以是单行单列也可以是多行单类的。
子查询可以作为条件，使用运算符去判断。运算符： > >= < <= =
子查询可以作为条件，使用运算符in来判断
4.什么是事务，什么是提交，什么是回滚
一个包含多个步骤的业务操作，被事务管理，这些操作要么同时成功要么同时失败。
commit
commit
5.mysql有几个隔离级别
read uncommitted：读未提交
read committed：读已提交（Oracle）
repeatable read：可重复读（MySQL默认）
serializable：串行化
6.数据库并发访问问题都有哪些
脏读
不可重复读
幻读

作者: 洪烁铭 时间: 2019-1-12 21:57
1.什么情况下会用到表连接查询
通过外键作为条件去查询表数据时，就是在表连接查询。需要查询多表关联的数据时使用。

2.表的连接查询有几种
内连接、外连接、子查询。
内连接是查询两个表中有交集的数据
外连接除了显示内连接的数据外，还能把一个表的全部数据进行显示。
子查询查询出来的数据是一个虚拟表，作为查询的条件来使用，即在查询中嵌套一个查询。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询作为查询的条件来使用，即在查询中嵌套一个查询。
分别有，单列单行；单列多行；多列多行；

4.什么是事务，什么是提交，什么是回滚
事务是执行一系列操作时，保证结果全部成功或者全部失败；
提交是在确保数据没错后，提交，以完成事务，释放资源。
回滚是在数据有误后，把数据返回到执行事务之前，以使错误数据不被执行。

5.mysql有几个隔离级别
四个：read unsubmited--可能产生脏读，不可重复读，幻读的问题 ;read submited--解决脏读问题，还会有不可重复读问题; repeatble read--解决不可重复读问题，还有幻读问题; serializable 解决幻读问题。

6.数据库并发访问问题都有哪些
脏读——可能发生数据发送给另一方，让其看到后，仍可撤回数据的问题；
不可重复读：在同一个事务中，两次读取到的数据不一样；
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 李灵杰 时间: 2019-1-12 21:59
1.什么情况下会用到表连接查询
查询多个表共有的数据,并且这些数据有主外键联系

2.表的连接查询有几种
多表查询
1.内连接查询：
1.隐式内连接：使用where条件消除无用数据
3.内连接查询：
1.从哪些表中查询数据
2.条件是什么
3.查询哪些字段
4.确定查询的字段
显式内连接：
2.外链接查询：
1.左外连接：
2.右外连接：
3.子查询：

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询
一条select语句可以作为虚拟表使用,返回给select语句使用子查询可以作为一张虚拟表参与查询
子查询可以作为条件，使用运算符去判断。
子查询可以作为条件，使用运算符in来判断
4.什么是事务，什么是提交，什么是回滚
一组操作数据的完整的流程,要么执行,要么报错
5.mysql有几个隔离级别
read committed
read uncommitted
repeatable read
serializable：串行化
6.数据库并发访问问题都有哪些
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
2. 虚读:不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
3.幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

作者: 吴洪标 时间: 2019-1-12 22:44
1.什么情况下会用到表连接查询
当需要查询的数据被存储在多张表中时，需要同时查询多张表，此时会用到表连接查询。

2.表的连接查询有几种
内连接：
1）隐式内连接：使用where条件建立连接，消除笛卡尔积中的无用数据；
2）显示内连接：使用关键字[inner] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表名1 [inner] join 表名2 on 条件。
外连接：
1）左外连接：使用关键字left [outer] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表1 left [outer] join 表2 on 条件；
2）右外连接：使用关键字right [outer] join建立连接，on关键字消除笛卡尔积找那个的无用数据。select 字段列表 from 表1 right [outer] join 表2 on 条件。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询是指在一个查询语句中嵌套了另一个查询语句：
1）子查询的结果是单行单列时，可以将子查询的结果作为条件，使用运算符进行判断；
2）子查询的结果是多行单列时，可以将子查询的结果作为条件，使用关键字in进行判断；
3）子查询的结果是多行多列时，可以将结果当成是一张虚表去参与查询。

4.什么是事务，什么是提交，什么是回滚
事务是指sql语句中的一个逻辑执行单位，在一个事务中执行多个sql语句，这些语句要么被同时成功执行，要么同时不被执行。
如果事务中的语句都成功执行，则commit语句会把执行结果永久化保存，这个操作也叫提交。
如果事务中的存在执行失败的语句，则rollback语句会将数据库恢复到事务开始的状态，这个操作也叫回滚。

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

6.数据库并发访问问题都有哪些
1）脏读：一个事务读取到另一个事务未提交的数据；
2）不可重复读（虚读）：一个事务中，前后读到的数据不一致，如同一个记录的balance，第一次读为100，第二次读为200，前后不一致；
3）幻读：一个事务中，针对某一范围（表全体记录，或者某一具体范围如1000-5000范围内的salary）的记录查询，前后查询的记录数量不一致，如第一次查询有5条记录，第二次查询有6条记录。造成幻读的原因是因为在这个事务的多次读取期间，另一个事务向同一张表插入（insert）了数据，造成记录数量的变化。

作者: 林文悦 时间: 2019-1-12 23:51
1.什么情况下会用到表连接查询
在一个表没办法满足我们的查询需求的时候，就会用到表的连接查询；

2.表的连接查询有几种
表的连接查询分为内连接查询和外连接查询，内连接查询又分为隐式内连接和显式内连接，隐式内连接用where限定去消除无用的笛卡尔积信息，而显式内连接用关键字 [inner] join  on 来消除无用的笛卡尔积信息。外连接分为左外连接和右外连接，左外连接是保留左表的所有信息和交集信息，右外连接是保留右表的所有信息和交集信息。

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询的概念有：1、一个查询的结果作为另一个查询的条件。2、有查询的嵌套，内部的查询称为子查询。3、子查询要使用括号
子查询的结果有3种情况，1、单行单列 2、多行单列 3、多行多列。  前面两个查询的结果可以作为另一个查询的条件，而多行多列这种情况是作为一张虚表跟其他的表一起参与查询，即嵌套的查询

4.什么是事务，什么是提交，什么是回滚
当一个业务由几个步骤完成时，用事务可以使业务要嘛所有操作都成功，要嘛所有操作都失败。
开启事务后，如果业务操作过程中出现错误，可以进行回滚，把数据返回到业务操作前。
开启事务后，如果业务操作没有问题，可以进行提交，将更改后的数据永久保存到数据库。

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

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

  产生的问题：脏读、不可重复读、幻读

作者: 苏阿合 时间: 2019-1-12 23:59
1.什么情况下会用到表连接查询
当我们查询的数据，需要用到多张表进行查询才能得到我们想要的数据时，此时需要连接多个表进行关联查询

2.表的连接查询有几种
有三种
(1)内连接查询：分为隐式内连接和显示式内连接，隐式内连接用where来消除无用数据，显示内连接用on来消除无用数据，用where进行进步一筛选，它们查询显示的是两表符合条件的，不符合不会显示出来。
(2)外连接查询：分为左外查询和右外查询，分别根据左或右表查询匹配条件，会查询显示左表或右表的所有数据和匹配到的数据，如果没有匹配到的数据则显示null
(3)子查询：当查询条件不能直接拿到，需要我们经过查询才能拿到，我们可以将将一个查询的结果作为另一个查询的条件或虚拟表进行关联查询，得到我们想要的数据

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)数据表中所有记录，此时另一个事务添加了一条数据，则第一个事务查询读到有一行数据是没有修改的，但其实这行是从第二个事务添加进去的，让人产生错觉

作者: ab8846254 时间: 2019-1-16 21:11
1.什么情况下会用到表连接查询
答：1.当数据在不同的表的时候需要用到表连接查询，也叫多表查询，查询出来的数据是笛卡尔积数据，需要用主键和外键过滤掉重复数据。
2.表的连接查询有几种
答：1.显示内连接查询，
   2.隐式内连接查询，
   3.左外键连接查询，
   4.右外键连接查询
   5.子查询：用一条查询语句出来的结果作为另一条语句的查询条件
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：用一条SQL语句的结果作为另外一条语句的条件
   查询的结果是单行单列的,直接使用聚合函数查询出来的数据
   查询结果是多行单列的,使用运算符in来判断
   查询结果是多行多列的,可以把查询出来的表作为一个虚拟表参与查询.
4.什么是事务，什么是提交，什么是回滚
答：保证两个连接进行增删数据的时候的数据安全性，叫做事物，必须要两个同时成功才能更新到数据库，否则将不会把数据提交到数据库
   mysql 默认的事物提交是默认开启的，我们可以把它更改为手动提交，提交事物的意思是说，当做了某些增删改数据库数据的时候我们需要把这一条记录保存到数据库中，叫做提交，回滚的意思是说，当开启事物后，若在中途操作异常则会进行数据还原，还原到数据最初的样子，开启事物需要庸才 try  case 语句块把回滚放在case语句里面。当发生了异常会执行回滚操作。

5.mysql有几个隔离级别
答：总共4个隔离集合
   1.读以提交
      2.读未提交
   3.可重复读
   4.串行化

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

作者: 李柏刚 时间: 2019-1-17 21:45

1.什么情况下会用到表连接查询
需要查询的数据在2个或多个表中，就需要用到表连接查询。
2.表的连接查询有几种
4种：显式内连接，隐式内连接，左外连接，右外连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询语句中嵌套查询语句，就称之为子查询。
子查询有3种情况，分别如下
单行单列：结果为单个数据，可以使用运算符参与判断。运算符： > >= < <= =
多行单列：结果为2个以上数据，可以使用运算符in来参与判断。
多行多列：结果为多行多列，可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败，这就是事务。
一个和多个步骤全部操作成功，使用commit，进行提交，如果当中有失败语句，就不会提交，可以使用rollback，进行回滚，也就是回到初始状态，数据不会发生修改。
5.mysql有几个隔离级别
4个隔离级别。按从低到高的级别排序分别为：read uncommitted； read committed； repeatable read；serializable；
隔离级别从小到大安全性越来越高，但是效率越来越低
6.数据库并发访问问题都有哪些
会产生数据修改错误，读取错误。例如：一个事务，读取到另一个事务中没有提交的数据；在同一个事务中，两次读取到的数据不一样；一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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

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