黑马程序员技术交流社区

标题: 【厦门校区JavaEE就业3期-每日总结】Mysql多表查询与事务的操作 [打印本页]
作者: 厦门校区    时间: 2018-9-4 21:34
标题: 【厦门校区JavaEE就业3期-每日总结】Mysql多表查询与事务的操作
1.什么情况下会用到表连接查询
2.表的连接查询有几种
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
4.什么是事务，什么是提交，什么是回滚
5.mysql有几个隔离级别
6.数据库并发访问问题都有哪些
作者: 黄艺纯    时间: 2018-9-4 21:36
本帖最后由 黄艺纯 于 2018-9-4 22:01 编辑

1.什么情况下会用到表连接查询消除笛卡尔积
2.表的连接查询有几种
连接查询有三种：
  1.内连接查询（隐式内连接、显示内连接）；
  2.外连接查询（左外连接、右外连接）；
  3.子查询。
                          
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
    子查询：子查询是一种常用计算机语言SELECT-SQL语言中嵌套查询下层的程序模块。当一个查询是另一个查询的条件时，称之为子查询。
子查询的结果又三种情况：
1.子查询的结果是一个值的时候：
    子查询结果只要是单行单列，肯定可以在where后面作为条件，父查询使用比较运算符，如：<,>,<>,=等；
2.子查询结果是多列单行的时候
    子查询结果是单列多行，结果集类似于一个数组，父查询使用IN运算符；
3.子查询的结果是多行多列
    子查询结果只要是多行多列，肯定在FROM后面作为表（奶奶的，什么sb教材，外连接怎么解释，傻屌！）


4.什么是事务，什么是提交，什么是回滚
    事务：在实际的开发过程中，一个业务操作如：转账，往往是要多次访问数据库才能完成的。转 账是一个用户扣钱，另一个用户加钱。如果其中有一条 SQL 语句出现异常，这条 SQL 就可能执行失败。
    回滚：回滚指的是程序或数据处理错误，将程序或数据恢复到上一次正确状态的行为。回滚包括程序回滚和数据回滚等类型。

5.mysql有几个隔离级别
有4个隔离级别：
1.读未提交 read uncommitted；
2.读已提交 read committed；
3.可重复读 repeatable read  ；
4.串行化 serializable 。

6.数据库并发访问问题都有哪些
1.丢失更新；
2.脏读；
3.不可重复读；
4.幻读。
作者: 罗荣贵    时间: 2018-9-4 21:42
1.进行多表查询的时候会用到
2.内连接，外连接 ，子查询
3.查询中嵌套查询 ，有三种情况，一行一列 ，用>,<=,>=,<>来连接子查询，多行一列用 与 或者 或 连接查询 ，多行多列 把字查询当成虚拟表使用
4.完成一个操作有多个步骤，用事务管理器操作，要么同时成功要么同时失败，提交是完成这个任务操作保存数据到文件，回滚是在操作任务过程中某些sql语句执行失败，回滚到开启事务
5.            1. read uncommitted：读未提交
                        * 产生的问题：脏读、不可重复读、幻读
                2. read committed：读已提交 （Oracle）
                        * 产生的问题：不可重复读、幻读
                3. repeatable read：可重复读 （MySQL默认）
                        * 产生的问题：幻读
                4. serializable：串行化
                        * 可以解决所有的问题
6.脏读 ，虚读，幻读
作者: 黄伟佳    时间: 2018-9-4 21:44

1.什么情况下会用到表连接查询
多个表
2.表的连接查询有几种
1. 内连接查询：
2. 外链接查询：
3. 子查询：


3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询
单行单列作为条件，多行单列作为条件，多行多列为一张虚拟表
4.什么是事务，什么是提交，什么是回滚
类似于一键还原，
就是事态完成保存数据
回滚就是回到事态启动前的数据
5.mysql有几个隔离级别
4个级别
6.数据库并发访问问题都有哪些
虚读。幻读，藏独
作者: 张子建    时间: 2018-9-4 21:45
1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系
2.表的连接查询有几种
3种，内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，单行单列，多行单列，多行多列
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
提交：commit;回滚：rollback;
5.mysql有几个隔离级别
4个，1. read uncommitted：读未提交
2. read committed：读已提交 （Oracle）
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
        1. 脏读2. 不可重复读(虚读)        3. 幻读
作者: 罗建辉    时间: 2018-9-4 21:45
1.什么情况下会用到表连接查询
查询一个结果，需要用到多张表，此时用到连接查询


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

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
一个查询的结果做为另一个查询的条件有查询的嵌套，内部的查询称为子查询，
子查询的结果是单行单列：SELECT 查询字段 FROM 表 WHERE 字段=（子查询）;
子查询结果是多行单列的时候：SELECT 查询字段 FROM 表 WHERE 字段 IN （子查询）;
子查询的结果是多行多列：SELECT 查询字段 FROM （子查询） 表别名 WHERE 条件;

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


事务提交：commit 事务开启之后, 所有的操作都会临时保存到事务日志中, 事务日志只有在得到commit命令才会同步到数据表中，其他任何情况都会清空事务日志(rollback，断开连接)。


回滚：rollback 事务执行失败时，执行回滚操作，回到事务执行前打的状态

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


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


作者: liebstch    时间: 2018-9-4 21:46
陈建秋
1.什么情况下会用到表连接查询
  多表查询的时候会用到表连接
2.表的连接查询有几种
  三种，内连接查询，外链接查询，和子查询
  内连接查询分为 ：显示内连接（inner join on）
                             隐式内连接（where）
  外链接分为：左外连接和右外连接
  子查询：查询内嵌套查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
  子查询：查询内嵌套查询
  三种情况，单行单列，作为条件
                   多行单列，in
                  多行多列，作为虚拟表
4.什么是事务，什么是提交，什么是回滚
                 事务就是保证多个业务的的操作的一起成功或者失败
                 提交就是将临时数据存入数据库
                回滚就是将数据库数据恢复到开启事务时的状态
5.mysql有几个隔离级别
                4个 读未提交，读已提交，可重复读，串行化
6.数据库并发访问问题都有哪些
                脏数据：读到临时数据
                虚读：一个事务下可以读出不同的数据
                幻读： 一个事务操作表中的所有记录，另一个事务插入数据，第一个事务无法读到自己改动。



作者: yangshixian    时间: 2018-9-4 21:46
1.什么情况下会用到表连接查询当进行多表查询的时候

2.表的连接查询有几种
四种，有内连接和外连接，内连接又分为显式内连接和隐式内连接，外连接分为左连接和右连接

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


4.什么是事务，什么是提交，什么是回滚
包含多个步骤的业务操作，这些操作要么同时成功，要么同时失败，称为事务
提交为将临时文件提交给数据库，确定数据
回滚为将临时文件清空

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


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

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



杨式贤

作者: 迪亚波罗    时间: 2018-9-4 21:46
1。多表查询
2.内连接:隐式内连接,显式内连接  外连接:左外连接,右外连接 子连接
3.查询嵌套查询,单行单列(通配符 < > >= <= <>) 多行单列(in),多行多列(子查询当作虚拟表)
4.对一件完成一个操作有多个步骤，用事务管理器操作，要么同时成功要么同时失败.提交是完成这个任务操作保存数据到文件，回滚是在操作任务过程中某些sql语句执行失败，回滚到开启事务
5.4个隔离级别(读未提交,读已提交,幻读,串行化)
6.脏读 ,不可重复读,幻读

孙享
作者: 张煜兴    时间: 2018-9-4 21:47
1.什么情况下会用到表连接查询
在进行多表查询时会用到表连接查询

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

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询，三种，单行单列作为条件、多行单列作为IN后的数组使用、多行多列作为虚拟表使用
4.什么是事务，什么是提交，什么是回滚
事务是多步骤、同时成败的一系列数据库操作；
提交是对一个事务的操作后数据进行保存；
回滚是事务中出错后回到开启事务前，不保存操作数据

5.mysql有几个隔离级别
4个隔离级别：
read uncommitted，存在三个问题
read committed，存在虚读和幻读两问题
repeatable read ，存在幻读问题
serializable，没有问题

6.数据库并发访问问题都有哪些
脏读：一次事务查到另一事务未提交的数据

虚读：不可重复读，一次事务两次读，数据不同
幻读：一次事务操作所以数据，另一个事务添加后，前一次事务察觉不到修改


作者: 谢君昇    时间: 2018-9-4 21:48
1.什么情况下会用到表连接查询
  当需要查询多个表的数据时;
2.表的连接查询有几种
  内连接查询,外连接查询;
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
  子查询:在查询中嵌套查询;
  三种:
         用在条件:单行单列,多行单列;
         虚拟表:多行多列;
4.什么是事务，什么是提交，什么是回滚
  事务:步骤被完整的执行称为事务;
   提交:表示事务已执行完毕
   回滚:事务中的步骤出错,返回到事务开启前的数据状态;
5.mysql有几个隔离级别
   read uncommitted：读未提交; read committed：读已提交 ; repeatable read：可重复读 ; serializable：串行化;
6.数据库并发访问问题都有哪些
脏读,虚读,幻读




作者: ZNBran    时间: 2018-9-4 21:49

1.什么情况下会用到表连接查询
查询多个表信息时会用到表连接查询
2.表的连接查询有几种
三种种，外连接、内连接和子查询。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，子查询结果有三种情况：子查询的结果是单行单列的可以作为条件，使用运算符去判断。 运算符： > >= < <= =。子查询的结果是多行单列的可以作为条件，使用运算符in来判断。子查询的结果是多行多列的可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚
事物就是包含一系列表操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
提交就是执行事物结果不发生错误就提交结果，回滚就是执行发现问题回滚事物。
5.mysql有几个隔离级别
四个隔离级别：read uncommitted：读未提交、 read committed：读已提交、repeatable read：可重复读、serializable：串行化。
6.数据库并发访问问题都有哪些
数据库事务并发带来的问题有：脏读、不可重复读、幻读。
==============================================周楠
作者: Michcale    时间: 2018-9-4 21:49
=============吴齐宾================================
1.什么情况下会用到表连接查询
当我们要在多行多列的表中查询某些数据的时候,为了消除无用数据我们会用到表连接查询
2.表的连接查询有几种
分为三种,一对一的查询,多对一和多对多
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询:1.单行单列.在where 后面使用
           2.多行单列,结尾类似为一个数组,使用in运算符查询
           3.多行多列,结果为一个虚拟表,用在from后面
4.什么是事务，什么是提交，什么是回滚
管理一个包含多个操作的业务,使这些操作要么同时发生,要么同时失败.
提交就是将操作成功之后的结果提交到数据库中进行持久化保存
回滚:操作失败之后,将程序或者说步骤回到开始之前的状态,
5.mysql有几个隔离级别
4个隔离级别
1) read uncommitted,
2)read committed,
3)repeatable read,
4)serializable
6.数据库并发访问问题都有哪些
脏读,虚读和幻读
作者: 林靖    时间: 2018-9-4 21:50
1.什么情况下会用到表连接查询
需要查找两张表同时存在的数据时
2.表的连接查询有几种
内链接查询
外连接查询
子查询

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

4.什么是事务，什么是提交，什么是回滚
包含多个操作的步骤叫做事务 要么同时失败 要么同时成功
COMMIT;提交 将更改后的数据 上传至数据库
ROLLBACK;回滚 产生异常后 初始化至事务开启时

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

6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
虚读：在同一个事务中，两次读取到的数据不一样
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。
作者: 铜墙铁壁花无缺    时间: 2018-9-4 21:51
本帖最后由 铜墙铁壁花无缺 于 2018-9-4 21:53 编辑

KingLong

1.什么情况下会用到表连接查询答：需要访问多张边的数据的时候
2.表的连接查询有几种
答：有三种  。 第一种是内连接查询 其中内连接查询分为隐式内连接查询和显示内连接查询   第二种是 外连接查询 其中外连接查询又分为左外连接查询和右外连接查询 第三章是子查询 ；
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
答：在查询中嵌套查询叫子查询
      子查询的结果有三种分三种情况
1 单行单列（可做为查询的条件）
2多行单列（可做为查询的条件）
3多行多列（子查询作为一张虚拟表）
4.什么是事务，什么是提交，什么是回滚
包含多个操作的步骤叫做事务 要么同时失败 要么同时成功
COMMIT;提交 将更改后的数据 上传至数据库

ROLLBACK;回滚 产生异常后 初始化至事务开启时

5.mysql有几个隔离级别
1. read uncommitted：读未提交
2. read committed：读已提交 （Oracle）
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
脏读：一个事务，读取到另一个事务中没有提交的数据
虚读：在同一个事务中，两次读取到的数据不一样
幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。
作者: shenxiaogan    时间: 2018-9-4 21:51

1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系
2.表的连接查询有几种
3种，内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，单行单列，多行单列，多行多列
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
提交：commit;回滚：rollback;
5.mysql有几个隔离级别
4个，1. read uncommitted：读未提交
2. read committed：读已提交 （Oracle）
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
        1. 脏读2. 不可重复读(虚读)        3. 幻读
作者: 小鱼七    时间: 2018-9-4 21:52
本帖最后由 小鱼七 于 2021-9-1 17:50 编辑

1.什么情况下会用到表连接查询
消除笛卡尔积，得到想要的数据
2.表的连接查询有几种
内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
嵌套查询，3种，单行单列，多行单列，多行多列


作者: weimengchao    时间: 2018-9-4 21:52

1.什么情况下会用到表连接查询
当我们要查询多个表得数据得时候
2.表的连接查询有几种
内连接
左外连接
右外连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
  在查询中嵌套查询;
  三种:
         用在条件:单行单列,多行单列;
         虚拟表:多行多列;
4.什么是事务，什么是提交，什么是回滚
多个操作得业务，所有代码要么一起成功，要么一起失败
5.mysql有几个隔离级别
4个级别
读不提交
读提交
可重复读
串行
6.数据库并发访问问题都有哪些
脏读，虚读，幻读
作者: 练志成    时间: 2018-9-4 21:54
1.什么情况下会用到表连接查询
要查看多张表的时候
2.表的连接查询有几种
三种分别是，内连续查询，外连接查询还有子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询是两个查询中镶嵌的·那个·，结果有三种
1，一行一列，可以当做条件使用（> <  <=  >=  <>）
2.一行多列，可以做条件使用（in）
3.多行多列，可以当做虚拟表使用
4.什么是事务，什么是提交，什么是回滚
事务就是一个操作要么同时失败，要么同时成功
提交就是事务完成后的确认
回滚就是操作失败后的保证，返回操作开始时的情况
5.mysl有几个隔离级别
四个，
6.数据库并发访问问题都有哪些
脏读
不可重复读
幻读
作者: 李伟javaee03    时间: 2018-9-4 21:54
1.        什么情况下会用到表连接查询
当需要进行多表查询操作的时候
2.表的连接查询有几种
内连接：隐式内连接、显示内连接
外连接：左外链接、右外连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
一个查询的结果做为另一个查询的条件，有查询的嵌套，内部的查询称为子查询
单行单列 where后使用比较运算符
多行单列 where后使用in
多行多列 在from后面作为表进行二次查询
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
开启事务： start transaction;
回滚：rollback;  开启事务执行出现问题进行回滚
提交：commit;   开启事务执行没有问题进行提交
5.mysql有几个隔离级别
1. read uncommitted：读未提交
2. read committed：读已提交
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
脏读、不可重复读、幻读
作者: 苏华琛    时间: 2018-9-4 21:55
1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系

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

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，单行单列，多行单列，多行多列
、
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

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

6.数据库并发访问问题都有哪些
脏读，不可重复读，幻读
作者: 吴鑫佳    时间: 2018-9-4 21:55
1.什么情况下会用到表连接查询
   当一个表需要另一个表的数据的时候，或者查询结果在多张不同的表中，则这个时候就需要表连接查询
2.表的连接查询有几种
  两种：1. 内连接查询：
a.隐式内连接：使用where条件消除无用数据
b.显式内连接：语法： 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.子查询的结果是多行多列的：子查询可以作为一张虚拟表参与查询。
4.什么是事务，什么是提交，什么是回滚
事物：在实际的开发过程中，一个业务操作。
提交：提交事务，会对数据库数据的数据进行改变
回滚：回滚事务，会回退到开启事务时的状态
5.mysql有几个隔离级别
四个，分别为1. read uncommitted：读未提交
                    2. read committed：读已提交 （Oracle）
                    3. repeatable read：可重复读 （MySQL默认）
                    4. serializable：串行化
                        * 可以解决所有的问题
6. 数据库并发访问问题都有哪些
脏读：一个事务读取到了另一个事务中尚未提交的数据
不可重复读：一个事务中两次读取的数据 内容 不一致，要求的是一个事务中多次读取时数据是一致的， 这是事务 update 时引发的问题
幻读：一个事务中两次读取的数据的数量不一致，要求在一个事务多次读取的数据的数量是一致
的，这是 insert 或 delete时引发的问题。
作者: 刘建宝    时间: 2018-9-4 21:55
1.什么情况下会用到表连接查询
当需要查询多个表信息时，通过表与表之间的联系，消除无用数据时需要表连接查询

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

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询时候嵌套查询，称为子查询
单行单列 当使用运算符（ > >= < <= =）判断嵌套查询时

多行单列 当使用运算符 IN 判断嵌套查询时
多行多列 当嵌套查询参与虚拟表查询时

4.什么是事务，什么是提交，什么是回滚
*  如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
当执行完事务时，需要提交事务，使事务中修改的数据持久化保存在数据库
当执行事务中途出现异常，会将之前发生变化的数据回归开启事务初始状态，并持久化保存数据

5.mysql有几个隔离级别
①read uncommitted：读未提交
②repeatable read：可重复读 （MySQL默认）
③serializable：串行化


6.数据库并发访问问题都有哪些
可以能会产生数据脏读，数据不重复读，幻毒；




作者: sulaymanfan    时间: 2018-9-4 21:56
1.什么情况下会用到表连接查询
  但同时用到多张表是,为保证数据的完整性
2.表的连接查询有几种
  内连接查询,外连接 子查询.
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
   子查询：一条select语句结果作为另一条select语法一部分（查询条件，查询结果，表等）。
    三种, 单列单行, 多行多列, 多汗单列
4.什么是事务，什么是提交，什么是回滚
   如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
5.mysql有几个隔离级别
  四个隔离级别
6.数据库并发访问问题都有哪些
   脏读,数据不重读,幻读




作者: 仰望｀星空    时间: 2018-9-4 21:56
郭林源

1.什么情况下会用到表连接查询-->需要的信息在两张不同表中时

2.表的连接查询有几种-->3种，内连接查询，外连接查询，子查询

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

4.什么是事务，什么是提交，什么是回滚-->就是一个多步骤的操作业务，被事务管理后，这些操作要么同时成功，要么同时失败。提交会同步数据表，回滚是当事务中的操作出现错误时，就可以将数据还原到开启事务的起点状态

5.mysql有几个隔离级别-->4个级别，1. read uncommitted   2. read committed   3. repeatable read  4. serializable

6.数据库并发访问问题都有哪些-->脏读、不可重复读、幻读
作者: 林嘉志    时间: 2018-9-4 21:56
1.什么情况下会用到表连接查询
消除多余的数据时
2.表的连接查询有几种
四种
隐式内链接
显示内链接  
左外连接
右外连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询语句作为条件，
三种
单行单列  做条件
多行单列 做条件
多行多列  做虚拟表
4.什么是事务，什么是提交，什么是回滚
一种机制，要么语句同时执行成功，要么同时失败
回滚就是将数据还原到原来的样子
5.mysql有几个隔离级别
四个  
1读未提交
2读已提交
3重复读
4串行化
隔离级别越高，效率越低
6.数据库并发访问问题都有哪些
脏读
不可重复读
幻读
作者: 沈智桂    时间: 2018-9-4 21:56
1.什么情况下会用到表连接查询
多表查询
2.表的连接查询有几种
3种 ，内连接查询 和外连接查询和子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
嵌套查询  ，单行单列 子查询作为条件 和多行单列 in 和多行多列 虚拟表
4.什么是事务，什么是提交，什么是回滚
一个包含多个步骤业务操作的，这些业务被事务管理，要么全部成功，要么全部不成功。
提交就是将临时数据存储到数据库中
回滚就是当事务发生错误，将事务回滚到开始事务前的状态
5.mysql有几个隔离级别
4个隔离级别
6.数据库并发访问问题都有哪些
1脏读 2不可重复读3 幻读
作者: 舟sir    时间: 2018-9-4 21:57
1.什么情况下会用到表连接查询
多表查询且子查询产生多行多列的虚表时
或者有外键约束关系，需要查询到外键信息的时候
2.表的连接查询有几种
二类四中：
内连接->隐式内连接/显示内连接
外连接->左外连接/右外连接查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
也称为嵌套查询，分为两种情况
单列：子查询作为条件
多列：子查询作为虚表
4.什么是事务，什么是提交，什么是回滚
事务是访问并可能更新数据库中各种数据项的一个程序执行单元，由事务开始和事务结束之间执行的全体操作组成，被事务修饰 要么完全执行，要么完全不执行称为事务。
提交：就是将事务所有操作的数据缓存转化为持久化的在数据库中存储。
回滚：是指条件不符合，不能完全执行，数据状态恢复到事务开始之前
5.mysql有几个隔离级别
四个隔离级别
读未提交
读已提交
可重复读
串行化
6.数据库并发访问问题都有哪些
脏读、不可重复读、幻读

周家乾




作者: 郑颖锋    时间: 2018-9-4 21:58
1.什么情况下会用到表连接查询
查询一个结果需要用到多张表时用表连接查询

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

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

4.什么是事务，什么是提交，什么是回滚
*  如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
如果事务中 SQL 语句没有问题，commit 提交事务，会对数据库数据的数据进行改变。 如果事务中 SQL
语句有问题，rollback 回滚事务，会回退到开启事务时的状态。

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

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


作者: 郑颖锋    时间: 2018-9-4 21:59
黄艺纯 发表于 2018-9-4 21:36
1.什么情况下会用到表连接查询
2.表的连接查询有几种
3.什么是子查询，子查询的结果有几种情况，分别怎么 ...

很棒                                                                  
作者: 赖良峰    时间: 2018-9-4 21:59
1.什么情况下会用到表连接查询     进行多表查询的时候
2.表的连接查询有几种
  三种  内连接 外链接  子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
    查询中嵌套查询  三种情况 单行单列 多行单列 多行多列
4.什么是事务，什么是提交，什么是回滚
  sql语句同时执行 同时成功 或者同时失败    将执行的sql语句的结果保存到数据库   不保存执行的结果
5.mysql有几个隔离级别
   1. read uncommitted：读未提交
                        * 产生的问题：脏读、不可重复读、幻读
                2. read committed：读已提交 （Oracle）
                        * 产生的问题：不可重复读、幻读
                3. repeatable read：可重复读 （MySQL默认）
                        * 产生的问题：幻读
                4. serializable：串行化
                        * 可以解决所有的问题
6.数据库并发访问问题都有哪些

1脏读
2可重复读
3幻读

作者: 陈捷    时间: 2018-9-4 22:00
1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系
2.表的连接查询有几种
3种，内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，单行单列，多行单列，多行多列
4.什么是事务，什么是提交，什么是回滚
1.什么情况下会用到表连接查询
查询结果在多张不同的表中，表与表之间又有关系
2.表的连接查询有几种
3种，内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询，单行单列，多行单列，多行多列
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
提交：commit;回滚：rollback;
5.mysql有几个隔离级别
隔离级别：
        1. read uncommitted：读未提交
            * 产生的问题：脏读、不可重复读、幻读
        2. read committed：读已提交 （Oracle）
            * 产生的问题：不可重复读、幻读
        3. repeatable read：可重复读 （MySQL默认）
            * 产生的问题：幻读
        4. serializable：串行化
            * 可以解决所有的问题
6.数据库并发访问问题都有哪些
        1. 脏读2. 不可重复读(虚读)        3. 幻读
5.mysql有几个隔离级别
4个，1. read uncommitted：读未提交
2. read committed：读已提交 （Oracle）
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
        1. 脏读2. 不可重复读(虚读)        3. 幻读
作者: 陈锦祥    时间: 2018-9-4 22:01
1.什么情况下会用到表连接查询
多表查询，且表与表之间存在关系
2.表的连接查询有几种
隐式内连接： SELECT  字段列表  FROM  表名1, 表名2  WHERE 条件;
显示内连接： select 字段列表 from 表名1 [inner] join 表名2 on 条件；
外左连接： select  字段列表 from 表名1  left  [outer]   join  表名2 on 条件；
外右连接：例：select 字段列表 from 表名1 rigth   [outer]   join  表名2 on 条件；
子查询：嵌套查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，称嵌套查询为子查询。 有三种情况：
1. 单行单列  可以作为条件
2. 多行单列  可以作为条件
3.多行多列  作为虚拟表
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
回滚：rollback  回到为操作前的数据状态
提交：数据操作成功
5.mysql有几个隔离级别
1. read uncommitted：读未提交  产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）  产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认） 产生的问题：幻读
4. serializable：串行化   可以解决所有的问题
6.数据库并发访问问题都有哪些
[td] 1. 脏读：一个事务，读取到另一个事务中没有提交的数据		        2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。        3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务    查询不到自己[/td]




作者: 赵烈刚    时间: 2018-9-4 22:02
1.什么情况下会用到表连接查询
查询一个结果需要用到多张表时；
2.表的连接查询有几种
三种；内连接，外连接，子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询中嵌套查询，嵌套查询称为子查询；三种情况，单行多列，多行多列，单行单列。
4.什么是事务，什么是提交，什么是回滚
1.开启事务：start transaction；
2.回滚：rollback；
3.提交：commit；
5.mysql有几个隔离级别
原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败。
持久性：当事务提交或回滚后，数据库会持久化的保存数据。
隔离性：多个事务之间。相互独立。
一致性：事务操作前后，数据总量不变
6.数据库并发访问问题都有哪些
脏读，虚读，幻读
作者: 冰是睡着的水    时间: 2018-9-4 22:02
1. 脏读：一个事务，读取到另一个事务中没有提交的数据
                2. 不可重复读(虚读)：在同一个事务中，两次读取到的数据不一样。
                        例如：第一次计算人员利用率为88%，过了几分钟变成了68%。
                3. 幻读：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。


（黄嘉欣）
作者: 郭生发    时间: 2018-9-4 23:05
1.什么情况下会用到表连接查询

    多表查询时
2.表的连接查询有几种

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

   嵌套查询是子查询
   结果有3种
  单行单列可作为条件查询
  多行单列可作为条件查询
  多行多列可作为一张虚拟表查询
4.什么是事务，什么是提交，什么是回滚

   事务是同时成功或同时失败
  当同时成功是提交
  当有一个失败时回滚，返回开启事务阶段
5.mysql有几个隔离级别

4个 read uncommitted 读未提交
      read committed 读已提交
      repeatable read 可重复读
      serializable   串行化
6.数据库并发访问问题都有哪些

  脏读，不可重复读，幻读
作者: MJ11    时间: 2018-9-4 23:44
1.什么情况下会用到表连接查询
      需要完成多张表的查询，消除无用的数据
2.表的连接查询有几种
  三种：内连接，外连接，子查询。
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
     子查询就是查询中嵌套查询
      三种情况：1. 子查询的结果是单行单列的，
                      使用：* 子查询可以作为条件，使用运算符去判断。 运算符： > >= < <= =
                       2.  查询的结果是多行单列的
                       * 子查询可以作为条件，使用运算符in来判断
                       3.子查询的情况是多行多列的
                       * 子查询可以作为一张虚拟表参与查询
4.什么是事务，什么是提交，什么是回滚
     事务就是一种机制1. 概念：
                *  如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
     提交就是commit，会对数据库数据的数据进行改变
     回滚就是rollback;，使用回滚会回退到开启事务时的状态
5.mysql有几个隔离级别
    四个隔离级别：1. read uncommitted：读未提交
                        * 产生的问题：脏读、不可重复读、幻读
                2. read committed：读已提交 （Oracle）
                        * 产生的问题：不可重复读、幻读
                3. repeatable read：可重复读 （MySQL默认）
                        * 产生的问题：幻读
                4. serializable：串行化
                        * 可以解决所有的问题
6.数据库并发访问问题都有哪些
    问题：1. 脏读
              2. 不可重复读(虚读)
             3. 幻读：

田浪
       
作者: 张剑猛    时间: 2018-9-5 21:04
1.什么情况下会用到表连接查询
当我们要查询多个表得数据得时候
2.表的连接查询有几种
内连接
左外连接
右外连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
一个查询的结果做为另一个查询的条件，有查询的嵌套，内部的查询称为子查询
单行单列 where后使用比较运算符
多行单列 where后使用in
多行多列 在from后面作为表进行二次查询
4.什么是事务，什么是提交，什么是回滚
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败
开启事务： start transaction;
回滚：rollback;  开启事务执行出现问题进行回滚
提交：commit;   开启事务执行没有问题进行提交
5.mysql有几个隔离级别
4个级别
读不提交
读提交
可重复读
串行
6.数据库并发访问问题都有哪些
脏读，虚读，幻读
作者: 林胜强    时间: 2018-9-5 21:25

1.什么情况下会用到表连接查询
当需要进行多表查询操作的时候
2.表的连接查询有几种
内连接：隐式内连接、显示内连接
外连接：左外链接、右外连接
子查询
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
一个查询的结果做为另一个查询的条件，有查询的嵌套，内部的查询称为子查询
单行单列 where后使用比较运算符
多行单列 where后使用in
多行多列 在from后面作为表进行二次查询
4.什么是事务，什么是提交，什么是回滚
被事务管理，要么同时成功，要么同时失败，提交：将执行完的语句，永久保存，回滚：恢复到语句执行前的数据
5.mysql有几个隔离级别
1. read uncommitted：读未提交
2. read committed：读已提交
3. repeatable read：可重复读 （MySQL默认）
4. serializable：串行化
6.数据库并发访问问题都有哪些
脏读、不可重复读、幻读
作者: zouyitao    时间: 2018-9-5 21:25
邹毅涛
1.什么情况下会用到表连接查询
查询的字段在不同的表中用多表查询
2.表的连接查询有几种
内连接、外连接、子连接
3.什么是子查询，子查询的结果有几种情况，分别怎么使用
查询内嵌套查询，子查询的结果有单行单列：作为条件，单行多列用in，多行多列用虚拟表
4.什么是事务，什么是提交，什么是回滚
事务就是保证多个业务的的操作的一起成功或者失败
提交就是将临时数据存入数据库
回滚就是将数据库数据恢复到开启事务时的状态
5.mysql有几个隔离级别
4个 读为提交、读已提交、可重复读、串行化
6.数据库并发访问问题都有哪些
脏数据：读到临时数据
虚读：一个事务下可以读出不同的数据
幻读： 一个事务操作表中的所有记录，另一个事务插入数据，第一个事务无法读到自己改动。
作者: 李志超    时间: 2018-9-5 21:52

1.什么情况下会用到表连接查询
需要查询多表之间的关系

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

3.什么是子查询，子查询的结果有几种情况，分别怎么使用
子查询是查询内部嵌套查询，子查询有3种情况：单行单列，作为where条件使用；多行单列，配合in集合 作为where的条件使用；多行多列，相当于虚拟表，在from后面使用。

4.什么是事务，什么是提交，什么是回滚
被事务管理的多个SQL语句，要么同时成功，要么同时失败。
提交是将事务从缓存刷新到数据库持久存储；
回滚：返回到事务开始，清空缓存（数据库不变）。

5.mysql有几个隔离级别
4；读未提交，读已提交，可重复度，串行化

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



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