1.什么情况下会用到表连接查询
2.表的连接查询有几种
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
4.什么是事务，什么是提交，什么是回滚
5.mysql有几个隔离级别
6.数据库并发访问问题都有哪些

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

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.表的连接查询有几种
内连接查询：隐式内连接使用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)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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

1.什么情况下会用到表连接查询 答：当需要同时查询多张表的内容时，就会用到表连接查询。 2.表的连接查询有几种 答：表的连接查询分为内连接查询和外连接查询两种。 3.什么是子查询，子查询的结果有几种情况，分别怎么使用 答：子查询指的是将某条查询语句当做另一条查询语句的条件或者虚拟表来参与查询，也就是在查询中嵌套查询。 子查询的结果有三种：单行单列、多行单列、多行多列。 单行单列：子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =。 多行单列：子查询可以作为条件，使用运算符in来判断。 多行多列：子查询可以作为一张虚拟表参与查询。 4.什么是事务，什么是提交，什么是回滚 答：事务：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。 提交：当事务执行没有问题时，执行提交动作。提交包括自动提交和手动提交两种方式。 回滚：当事务执行出现问题时，执行回滚动作。回滚能够使数据回到事务执行前的样子。 5.mysql有几个隔离级别 答：①read uncommitted：读未提交。 产生的问题：脏读、不可重复读、幻读。 ②read committed：读已提交（Oracle）。 产生的问题：不可重复读、幻读。 ③repeatable read：可重复读（MySQL默认）。 产生的问题：幻读。 ④serializable：串行化。 可以解决所有的问题。 6.数据库并发访问问题都有哪些 答：1. 脏读：一个事务，读取到另一个事务中没有提交的数据。 2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。 3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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、脏读，当一个事务修改某个数据后，另一事务对该数据进行了读取，由于某种原因前一事务撤销了对改数据的修改，即将修改过的数据恢复原值，那么后一事务读到的数据与数据可得不一致，称之为读脏数据

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

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

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这个隔离级别来避免这个问题。

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操作时引起）

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

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

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

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

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

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

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