关于java:开发者进阿里必看的30道经典数据库面试题附详细解析

7次阅读

共计 15093 个字符，预计需要花费 38 分钟才能阅读完成。

什么是存储过程？有哪些优缺点？

存储过程就像咱们编程语言中的函数一样，封装了咱们的代码(PLSQL、T-SQL)。

存储过程的长处：

可能将代码封装起来
保留在数据库之中
让编程语言进行调用
存储过程是一个预编译的代码块，执行效率比拟高
一个存储过程代替大量 T_SQL 语句，能够升高网络通信量，进步通信速率

存储过程的毛病：

每个数据库的存储过程语法简直都不一样，非常难以保护（不通用）
业务逻辑放在数据库上，难以迭代

作为浏览福利小编整顿了数据库相干的面试题 + 外围知识点，须要的点击此处

三个范式是什么

第一范式（1NF）：数据库表中的字段都是繁多属性的，不可再分。这个繁多属性由根本类型形成，包含整型、实数、字符型、逻辑型、日期型等。第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的局部函数依赖（局部函数依赖指的是存在组合关键字中的某些字段决定非关键字段的状况），也即所有非关键字段都齐全依赖于任意一组候选关键字。
第三范式（3NF）：在第二范式的根底上，数据表中如果不存在非关键字段对任一候选关键字段的传递函数依赖则合乎第三范式。所谓传递函数依赖，指的是如果存在 ”A → B → C” 的决定关系，则 C 传递函数依赖于 A。因而，满足第三范式的数据库表应该不存在如下依赖关系：关键字段 → 非关键字段 x → 非关键字段 y

下面的文字咱们必定是看不懂的，也不违心看上来的。接下来我就总结一下：

首先要明确的是：满足着第三范式，那么就肯定满足第二范式、满足着第二范式就肯定满足第一范式
第一范式：字段是最小的的单元不可再分
- 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的
第二范式：满足第一范式,表中的字段必须齐全依赖于全副主键而非局部主键。
- 其余字段组成的这行记录和主键示意的是同一个货色，而主键是惟一的，它们只须要依赖于主键，也就成了惟一的
- 学号为 1024 的同学，姓名为 Java3y，年龄是 22 岁。姓名和年龄字段都依赖着学号主键。
第三范式：满足第二范式，非主键外的所有字段必须互不依赖
- 就是数据只在一个中央存储，不反复呈现在多张表中，能够认为就是打消传递依赖
- 比方，咱们大学分了很多系（中文系、英语系、计算机系……），这个系别治理表信息有以下字段组成：系编号，系主任，系简介，系架构。那咱们能不能在学生信息表增加系编号，系主任，系简介，系架构字段呢？不行的，因为这样就冗余了，非主键外的字段造成了依赖关系(依赖到学生信息表了)！正确的做法是：学生表就只能减少一个系编号字段。

什么是视图？以及视图的应用场景有哪些？

视图是一种基于数据表的一种虚表

（1）视图是一种虚表
（2）视图建设在已有表的根底上, 视图赖以建设的这些表称为基表
（3）向视图提供数据内容的语句为 SELECT 语句, 能够将视图了解为存储起来的 SELECT 语句
（4）视图向用户提供基表数据的另一种表现形式
（5）视图没有存储真正的数据，真正的数据还是存储在基表中
（6）程序员尽管操作的是视图，但最终视图还会转成操作基表
（7）一个基表能够有 0 个或多个视图

有的时候，咱们可能只关系一张数据表中的某些字段，而另外的一些人只关系同一张数据表的某些字段 …

那么把全副的字段都都显示给他们看，这是不合理的。

咱们应该做到：他们想看到什么样的数据，咱们就给他们什么样的数据 … 一方面就可能让他们只关注本人的数据，另一方面，咱们也保障数据表一些窃密的数据不会泄露进去 …

咱们在查问数据的时候，经常须要编写十分长的 SQL 语句，简直每次都要写很长很长 …. 下面曾经说了，视图就是基于查问的一种虚表，也就是说，视图能够将查问进去的数据进行封装。。。那么咱们在应用的时候就会变得十分不便…

值得注意的是：应用视图能够让咱们专一与逻辑，但不进步查问效率

drop、delete 与 truncate 别离在什么场景之下应用？

咱们来比照一下他们的区别：

drop table

1)属于 DDL
2)不可回滚
3)不可带 where
4)表内容和构造删除
5)删除速度快

truncate table

1)属于 DDL
2)不可回滚
3)不可带 where
4)表内容删除
5)删除速度快

delete from

1)属于 DML
2)可回滚
3)可带 where
4)表构造在，表内容要看 where 执行的状况
5)删除速度慢, 须要逐行删除
不再须要一张表的时候，用 drop
想删除局部数据行时候，用 delete，并且带上 where 子句
保留表而删除所有数据的时候用 truncate

索引是什么？有什么作用以及优缺点？

什么是索引【Index】

（1）是一种疾速查问表中内容的机制，相似于新华字典的目录
（2）使用在表中某个些字段上，但存储时，独立于表之外

索引表把数据变成是有序的 ….

疾速定位到硬盘中的数据文件 …

rowid 的特点

（1）位于每个表中，但外表上看不见，例如：desc emp 是看不见的
（2）只有在 select 中，显示写出 rowid，方可看见
（3）它与每个表绑定在一起，表亡，该表的 rowid 亡，二张表 rownum 能够雷同，但 rowid 必须是惟一的
（4）rowid 是 18 位大小写加数字混淆体，惟一表代该条记录在 DBF 文件中的地位
（5）rowid 能够参加 =/like 比拟时，用 ” 单引号将 rowid 的值包起来，且辨别大小写
（6）rowid 是分割表与 DBF 文件的桥梁

索引的特点

（1）索引一旦建设, Oracle 管理系统会对其进行主动保护, 而且由 Oracle 管理系统决定何时应用索引
（2）用户不必在查问语句中指定应用哪个索引
（3）在定义 primary key 或 unique 束缚后零碎主动在相应的列上创立索引
（4）用户也能按本人的需要，对指定单个字段或多个字段，增加索引

须要留神的是：Oracle 是主动帮咱们治理索引的，并且如果咱们指定了 primary key 或者 unique 束缚，零碎会主动在对应的列上创立索引..

什么时候【要】创立索引

（1）表常常进行 SELECT 操作
（2）表很大(记录超多)，记录内容散布范畴很广
（3）列名常常在 WHERE 子句或连贯条件中呈现

什么时候【不要】创立索引

（1）表常常进行 INSERT/UPDATE/DELETE 操作
（2）表很小(记录超少)
（3）列名不常常作为连贯条件或呈现在 WHERE 子句中

索引优缺点：

索引放慢数据库的检索速度
索引升高了插入、删除、批改等保护工作的速度 (尽管索引能够进步查问速度，然而它们也会导致数据库系统更新数据的性能降落， 因为大部分数据更新须要同时更新索引)
惟一索引能够确保每一行数据的唯一性，通过应用索引，能够在查问的过程中应用优化暗藏器，进步零碎的性能
索引须要占物理和数据空间

索引分类：

惟一索引：惟一索引不容许两行具备雷同的索引值
主键索引：为表定义一个主键将主动创立主键索引，主键索引是惟一索引的非凡类型。主键索引要求主键中的每个值是惟一的，并且不能为空
汇集索引(Clustered)：表中各行的物理程序与键值的逻辑（索引）程序雷同，每个表只能有一个
非汇集索引(Non-clustered)：非汇集索引指定表的逻辑程序。数据存储在一个地位，索引存储在另一个地位，索引中蕴含指向数据存储地位的指针。能够有多个，小于 249 个

什么是事务？

事务简略来说：一个 Session 中所进行所有的操作，要么同时胜利，要么同时失败

ACID — 数据库事务正确执行的四个基本要素

蕴含：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。

一个反对事务（Transaction）中的数据库系统，必须要具备这四种个性，否则在事务过程（Transaction processing）当中无奈保证数据的正确性，交易过程极可能达不到交易。

举个例子: A 向 B 转账，转账这个流程中如果呈现问题，事务能够让数据恢复成原来一样【A 账户的钱没变，B 账户的钱也没变】。

事例阐明：


        /*
        * 咱们来模仿 A 向 B 账号转账的场景
        *   A 和 B 账户都有 1000 块，当初我让 A 账户向 B 账号转 500 块钱
        *
        * */
            //JDBC 默认的状况下是敞开事务的，上面咱们看看敞开事务去操作转账操作有什么问题

            // A 账户减去 500 块
            String sql = "UPDATE a SET money=money-500";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();

            // B 账户多了 500 块
            String sql2 = "UPDATE b SET money=money+500";
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();

从下面看，咱们确实能够发现 A 向 B 转账，胜利了。可是 如果 A 向 B 转账的过程中呈现了问题呢？上面模仿一下


            // A 账户减去 500 块
            String sql = "UPDATE a SET money=money-500";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();

            // 这里模仿呈现问题
            int a = 3 / 0;

            String sql2 = "UPDATE b SET money=money+500";
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();

显然，下面 代码是会抛出异样的 ，咱们再来查问一下数据。 A 账户少了 500 块钱，B 账户的钱没有减少。 这显著是不合理的。

咱们能够通过事务来解决下面呈现的问题


            // 开启事务, 对数据的操作就不会立刻失效。connection.setAutoCommit(false);

            // A 账户减去 500 块
            String sql = "UPDATE a SET money=money-500";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();

            // 在转账过程中呈现问题
            int a = 3 / 0;

            // B 账户多 500 块
            String sql2 = "UPDATE b SET money=money+500";
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();

            // 如果程序能执行到这里，没有抛出异样，咱们就提交数据
            connection.commit();

            // 敞开事务【主动提交】connection.setAutoCommit(true);

        } catch (SQLException e) {
            try {
                // 如果呈现了异样，就会进到这里来，咱们就把事务回滚【将数据变成原来那样】connection.rollback();

                // 敞开事务【主动提交】connection.setAutoCommit(true);
            } catch (SQLException e1) {e1.printStackTrace();
            }

下面的程序也一样抛出了异样，A 账户钱没有缩小，B 账户的钱也没有减少。

留神：当 Connection 遇到一个未解决的 SQLException 时，零碎会非正常退出，事务也会主动回滚，但 如果程序捕捉到了异样，是须要在 catch 中显式回滚事务的。

数据库定义了 4 个隔离级别：

Serializable【可防止脏读，不可反复读，虚读】
Repeatable read【可防止脏读，不可反复读】
Read committed【可防止脏读】
Read uncommitted【级别最低，什么都防止不了】

别离对应 Connection 类中的 4 个常量

TRANSACTION_READ_UNCOMMITTED
TRANSACTION_READ_COMMITTED
TRANSACTION_REPEATABLE_READ
TRANSACTION_SERIALIZABLE

- *

脏读：一个事务读取到另外一个事务未提交的数据

例子：A 向 B 转账， A 执行了转账语句，但 A 还没有提交事务，B 读取数据，发现自己账户钱变多了！B 跟 A 说，我曾经收到钱了。A 回滚事务【rollback】，等 B 再查看账户的钱时，发现钱并没有多。

不可反复读：一个事务读取到另外一个事务曾经提交的数据，也就是说一个事务能够看到其余事务所做的批改

注： A 查询数据库失去数据，B 去批改数据库的数据，导致 A 屡次查询数据库的后果都不一样【危害：A 每次查问的后果都是受 B 的影响的，那么 A 查问进去的信息就没有意思了】

虚读 (幻读)： 是指在一个事务内读取到了别的事务插入的数据，导致前后读取不统一。

注：和不可反复读相似，但虚读 (幻读) 会读到其余事务的插入的数据，导致前后读取不统一

简略总结：脏读是不可容忍的，不可反复读和虚读在肯定的状况下是能够的【做统计的必定就不行】。

数据库的乐观锁和乐观锁是什么？

确保在多个事务同时存取数据库中同一数据时不毁坏事务的隔离性和统一性以及数据库的统一性，乐观锁和乐观锁是并发管制次要采纳的技术手段。

乐观锁：假设会产生并发抵触，屏蔽所有可能违反数据完整性的操作
- 在查问完数据的时候就把事务锁起来，直到提交事务
- 实现形式：应用数据库中的锁机制
乐观锁：假如不会产生并发抵触，只在提交操作时查看是否违反数据完整性。
- 在批改数据的时候把事务锁起来，通过 version 的形式来进行锁定
- 实现形式：应用 version 版本或者工夫戳

乐观锁：

超键、候选键、主键、外键别离是什么？

超键：在关系中能惟一标识元组的属性集称为关系模式的超键 。一个属性能够为作为一个超键，多个属性组合在一起也能够作为一个超键。 超键蕴含候选键和主键。
候选键(候选码)：是最小超键，即没有冗余元素的超键。
主键(主码)：数据库表中对贮存数据对象予以惟一和残缺标识的数据列或属性的组合。一个数据列只能有一个主键，且主键的取值不能缺失，即不能为空值（Null）。
外键：在一个表中存在的另一个表的主键称此表的外键。

候选码和主码：

例子：邮寄地址（城市名，街道名，邮政编码，单位名，收件人）

它有两个候选键:{城市名，街道名} 和 {街道名，邮政编码}
如果我选取 {城市名，街道名} 作为惟一标识实体的属性，那么{城市名，街道名} 就是主码(主键)

SQL 束缚有哪几种？

NOT NULL: 用于管制字段的内容肯定不能为空（NULL）。
UNIQUE: 控件字段内容不能反复，一个表容许有多个 Unique 束缚。
PRIMARY KEY: 也是用于控件字段内容不能反复，但它在一个表只容许呈现一个。
FOREIGN KEY: 用于预防毁坏表之间连贯的动作，也能避免非法数据插入外键列，因为它必须是它指向的那个表中的值之一。
CHECK: 用于管制字段的值范畴。

数据库运行于哪种状态下能够避免数据的失落？

在 archivelog mode(归档模式)只有其归档日志文件不失落，就能够无效地避免数据失落。

Mysql 的存储引擎有以下几种：

我的是 5.7.15 版本，默认应用的是 Innodb 版本！

罕用的存储引擎有以下：

Innodb 引擎，Innodb 引擎提供了对数据库 ACID 事务的反对。并且还提供了行级锁和外键的束缚。它的设计的指标就是解决大数据容量的数据库系统。
MyIASM 引擎(本来 Mysql 的默认引擎), 不提供事务的反对，也不反对行级锁和外键。
MEMORY 引擎：所有的数据都在内存中，数据的处理速度快，然而安全性不高。

同一个数据库也能够应用多种存储引擎的表。如果一个表批改要求比拟高的事务处理，能够抉择 InnoDB。这个数据库中能够将查问要求比拟高的表抉择 MyISAM 存储。如果该数据库须要一个用于查问的长期表，能够抉择 MEMORY 存储引擎。

MyIASM 和 Innodb 两种引擎所应用的索引的数据结构是什么？

答案: 都是 B + 树!

MyIASM 引擎，B+ 树的数据结构中存储的内容实际上是理论数据的地址值。也就是说它的索引和理论数据是离开的，只不过应用索引指向了理论数据。这种索引的模式被称为非汇集索引。

Innodb 引擎的索引的数据结构也是 B + 树，只不过数据结构中存储的都是理论的数据，这种索引有被称为汇集索引。

varchar 和 char 的区别

Char 是一种固定长度的类型，varchar 是一种可变长度的类型

mysql 无关权限的表都有哪几个

MySQL 服务器通过权限表来管制用户对数据库的拜访，权限表寄存在 mysql 数据库里，由 mysql_install_db 脚本初始化。这些权限表别离 user，db，table_priv，columns_priv 和 host。上面别离介绍一下这些表的构造和内容：

user 权限表：记录容许连贯到服务器的用户帐号信息，外面的权限是全局级的。
db 权限表：记录各个帐号在各个数据库上的操作权限。
table_priv 权限表：记录数据表级的操作权限。
columns_priv 权限表：记录数据列级的操作权限。
host 权限表：配合 db 权限表对给定主机上数据库级操作权限作更粗疏的管制。这个权限表不受 GRANT 和 REVOKE 语句的影响。

数据表损坏的修复形式有哪些？

应用 myisamchk 来修复，具体步骤：

1）修复前将 mysql 服务进行。
2）关上命令行形式，而后进入到 mysql 的 /bin 目录。
3）执行 myisamchk –recover 数据库所在门路 /*.MYI

应用 repair table 或者 OPTIMIZE table 命令来修复，REPAIR TABLE table_name 修复表 OPTIMIZE TABLE table_name 优化表 REPAIR TABLE 用于修复被毁坏的表。OPTIMIZE TABLE 用于回收闲置的数据库空间，当表上的数据行被删除时，所占据的磁盘空间并没有立刻被回收，应用了 OPTIMIZE TABLE 命令后这些空间将被回收，并且对磁盘上的数据行进行重排（留神：是磁盘上，而非数据库）

MySQL 中 InnoDB 引擎的行锁是通过加在什么上实现

InnoDB 是基于索引来实现行锁

例: select * from tab_with_index where id = 1 for update;

for update 能够依据条件来实现行锁锁定,并且 id 是有索引键的列,

如果 id 不是索引键那么 InnoDB 将实现表锁,, 并发将无从谈起

在咱们书写 SQL 语句的时候，其实书写的程序、策略会影响到 SQL 的性能，尽管实现的性能是一样的，然而它们的性能会有些许差异。

因而，上面就解说在书写 SQL 的时候，怎么写比拟好。

数据库的解析器依照 从右到左的程序解决 FROM 子句中的表名，FROM 子句中写在最初的表将被最先解决

在 FROM 子句中蕴含多个表的状况下：

如果三个表是齐全无关系的话，将记录和列名起码的表，写在最初，而后顺次类推
也就是说：抉择记录条数起码的表放在最初

如果有 3 个以上的表连贯查问：

如果三个表是有关系的话，将援用最多的表，放在最初，而后顺次类推。
也就是说：被其余表所援用的表放在最初

例如：查问员工的编号，姓名，工资，工资等级，部门名

emp 表被援用得最多，记录数也是最多，因而放在 form 字句的最初面


select emp.empno,emp.ename,emp.sal,salgrade.grade,dept.dname
from salgrade,dept,emp
where (emp.deptno = dept.deptno) and (emp.sal between salgrade.losal and salgrade.hisal)

数据库采纳自 右而左的程序解析 WHERE 子句 , 依据这个原理, 表之间的连贯必须写在其余 WHERE 条件之左 , 那些 能够过滤掉最大数量记录的条件必须写在 WHERE 子句的之右。

emp.sal 能够过滤多条记录，写在 WHERE 字句的最左边


      select emp.empno,emp.ename,emp.sal,dept.dname
      from dept,emp
      where (emp.deptno = dept.deptno) and (emp.sal > 1500)

咱们过后学习的时候，“*”号是能够获取表中全副的字段数据的。

然而它要通过查问数据字典实现的，这意味着将消耗更多的工夫
应用 * 号写进去的 SQL 语句也不够直观。
- *

这里仅仅是：删除表的全副记录，除了表构造才这样做。

DELETE 是一条一条记录的删除，而 Truncate 是将整个表删除，保留表构造，这样比 DELETE 快

例如应用 mysql 的 concat()函数会比应用 || 来进行拼接快，因为 concat()函数曾经被 mysql 优化过了。

如果表或列的名称太长了，应用一些简短的别名也能略微进步一些 SQL 的性能。毕竟要扫描的字符长度就变少了。。。

comiit 会开释回滚点 …

索引就是为了进步咱们的查问数据的，当表的记录量十分大的时候，咱们就能够应用索引了。

咱们在编写 SQL 的时候，官网举荐的是应用大写来写关键字，因为 Oracle 服务器总是先将小写字母转成大写后，才执行

因为 Oracle 服务器遇到 NOT 后，他就会进行目前的工作，转而执行全表扫描

WHERE 子句中，如果索引列是函数的一部分，优化器将不应用索引而应用全表扫描，这样会变得变慢

①②用 `>=` 代替 `>`

      低效：SELECT * FROM EMP WHERE DEPTNO > 3   
      首先定位到 DEPTNO= 3 的记录并且扫描到第一个 DEPT 大于 3 的记录
      高效：SELECT * FROM EMP WHERE DEPTNO >= 4  
      间接跳到第一个 DEPT 等于 4 的记录


      select * from emp where sal = 1500 or sal = 3000 or sal = 800;
      select * from emp where sal in (1500,3000,800);

如果索引是建设在多个列上，只有在它的第一个列被 WHERE 子句援用时，优化器才会抉择应用该索引。当只援用索引的第二个列时，不援用索引的第一个列时，优化器应用了全表扫描而疏忽了索引


      create index emp_sal_job_idex
      on emp(sal,job);
      ----------------------------------
      select *
      from emp  
      where job != 'SALES';    

      上边就不应用索引了。

1）范式优化：比方打消冗余（节俭空间。。）
2）反范式优化：比方适当加冗余等（缩小 join）
3）拆分表：垂直拆分和程度拆分

这个么多花钱咯！

根本表构造：

student(sno,sname,sage,ssex)学生表
course(cno,cname,tno) 课程表
sc(sno,cno,score) 成绩表

teacher(tno,tname) 老师表

题目：


101，查问课程 1 的问题比课程 2 的问题高的所有学生的学号
select a.sno from
(select sno,score from sc where cno=1) a,
(select sno,score from sc where cno=2) b
where a.score>b.score and a.sno=b.sno

102，查问均匀问题大于 60 分的同学的学号和均匀问题
select a.sno as "学号", avg(a.score) as "均匀问题" 
from
(select sno,score from sc) a 
group by sno having avg(a.score)>60

103，查问所有同学的学号、姓名、选课数、总成绩
select a.sno as 学号, b.sname as 姓名,
count(a.cno) as 选课数, sum(a.score) as 总成绩
from sc a, student b
where a.sno = b.sno
group by a.sno, b.sname

或者：selectstudent.sno as 学号, student.sname as 姓名,
 count(sc.cno) as 选课数, sum(score) as 总成绩
from student left Outer join sc on student.sno = sc.sno
group by student.sno, sname

104，查问姓“张”的老师的个数

selectcount(distinct(tname)) from teacher where tname like ' 张 %‘或者：select tname as "姓名", count(distinct(tname)) as "人数" 
from teacher 
where tname like'张 %'
group by tname

105，查问没学过“张三”老师课的同学的学号、姓名
select student.sno,student.sname from student
where sno not in (select distinct(sc.sno) from sc,course,teacher
where sc.cno=course.cno and teacher.tno=course.tno and teacher.tname='张三')

106，查问同时学过课程 1 和课程 2 的同学的学号、姓名
select sno, sname from student
where sno in (select sno from sc where sc.cno = 1)
and sno in (select sno from sc where sc.cno = 2)
或者：selectc.sno, c.sname from
(select sno from sc where sc.cno = 1) a,
(select sno from sc where sc.cno = 2) b,
student c
where a.sno = b.sno and a.sno = c.sno
或者：select student.sno,student.sname from student,sc where student.sno=sc.sno and sc.cno=1
and exists(select * from sc as sc_2 where sc_2.sno=sc.sno and sc_2.cno=2)

107，查问学过“李四”老师所教所有课程的所有同学的学号、姓名
select a.sno, a.sname from student a, sc b
where a.sno = b.sno and b.cno in
(select c.cno from course c, teacher d where c.tno = d.tno and d.tname = '李四')

或者：select a.sno, a.sname from student a, sc b,
(select c.cno from course c, teacher d where c.tno = d.tno and d.tname = '李四') e
where a.sno = b.sno and b.cno = e.cno

108，查问课程编号 1 的问题比课程编号 2 的问题高的所有同学的学号、姓名
select a.sno, a.sname from student a,
(select sno, score from sc where cno = 1) b,
(select sno, score from sc where cno = 2) c
where b.score > c.score and b.sno = c.sno and a.sno = b.sno

109，查问所有课程问题小于 60 分的同学的学号、姓名
select sno,sname from student
where sno not in (select distinct sno from sc where score > 60)

110，查问至多有一门课程与学号为 1 的同学所学课程雷同的同学的学号和姓名
select distinct a.sno, a.sname
from student a, sc b
where a.sno <> 1 and a.sno=b.sno and
b.cno in (select cno from sc where sno = 1)

或者：select s.sno,s.sname 
from student s,
(select sc.sno 
from sc
where sc.cno in (select sc1.cno from sc sc1 where sc1.sno=1)and sc.sno<>1
group by sc.sno)r1
where r1.sno=s.sno

111、把“sc”表中“王五”所教课的问题都更改为此课程的均匀问题
update sc set score = (select avg(sc_2.score) from sc sc_2 wheresc_2.cno=sc.cno)
from course,teacher where course.cno=sc.cno and course.tno=teacher.tno andteacher.tname='王五'

112、查问和编号为 2 的同学学习的课程完全相同的其他同学学号和姓名
这一题分两步查：1，select sno
from sc
where sno <> 2
group by sno
having sum(cno) = (select sum(cno) from sc where sno = 2)

2，select b.sno, b.sname
from sc a, student b
where b.sno <> 2 and a.sno = b.sno
group by b.sno, b.sname
having sum(cno) = (select sum(cno) from sc where sno = 2)

113、删除学习“王五”老师课的 sc 表记录
delete sc from course, teacher
where course.cno = sc.cno and course.tno = teacher.tno and tname = '王五'

114、向 sc 表中插入一些记录，这些记录要求合乎以下条件：将没有课程 3 问题同学的该问题补齐, 其问题取所有学生的课程 2 的均匀问题
insert sc select sno, 3, (select avg(score) from sc where cno = 2)
from student
where sno not in (select sno from sc where cno = 3)

115、按平平均分从高到低显示所有学生的如下统计报表：-- 学号, 企业治理, 马克思,UML, 数据库, 物理, 课程数, 平均分
select sno as 学号
,max(case when cno = 1 then score end) AS 企业治理
,max(case when cno = 2 then score end) AS 马克思
,max(case when cno = 3 then score end) AS UML
,max(case when cno = 4 then score end) AS 数据库
,max(case when cno = 5 then score end) AS 物理
,count(cno) AS 课程数
,avg(score) AS 平均分
FROM sc
GROUP by sno
ORDER by avg(score) DESC

116、查问各科问题最高分和最低分：以如下模式显示：课程号，最高分，最低分
select cno as 课程号, max(score) as 最高分, min(score) 最低分
from sc group by cno

select  course.cno as '课程号'
,MAX(score) as '最高分'
,MIN(score) as '最低分'
from sc,course
where sc.cno=course.cno
group by course.cno

117、按各科均匀问题从低到高和及格率的百分数从高到低程序
SELECT t.cno AS 课程号,
max(course.cname)AS 课程名,
isnull(AVG(score),0) AS 均匀问题,
100 * SUM(CASE WHEN isnull(score,0)>=60 THEN 1 ELSE 0 END)/count(1) AS 及格率
FROM sc t, course
where t.cno = course.cno
GROUP BY t.cno
ORDER BY 及格率 desc

118、查问如下课程均匀问题和及格率的百分数(用 "1 行" 显示): 

企业治理（001），马克思（002），UML（003），数据库（004）select 
avg(case when cno = 1 then score end) as 平均分 1,
avg(case when cno = 2 then score end) as 平均分 2,
avg(case when cno = 3 then score end) as 平均分 3,
avg(case when cno = 4 then score end) as 平均分 4,
100 * sum(case when cno = 1 and score > 60 then 1 else 0 end) / sum(casewhen cno = 1 then 1 else 0 end) as 及格率 1,
100 * sum(case when cno = 2 and score > 60 then 1 else 0 end) / sum(casewhen cno = 2 then 1 else 0 end) as 及格率 2,
100 * sum(case when cno = 3 and score > 60 then 1 else 0 end) / sum(casewhen cno = 3 then 1 else 0 end) as 及格率 3,
100 * sum(case when cno = 4 and score > 60 then 1 else 0 end) / sum(casewhen cno = 4 then 1 else 0 end) as 及格率 4
from sc

119、查问不同老师所教不同课程平均分, 从高到低显示
select max(c.tname) as 老师, max(b.cname) 课程, avg(a.score) 平均分
from sc a, course b, teacher c
where a.cno = b.cno and b.tno = c.tno
group by a.cno
order by 平均分 desc
或者：select r.tname as '老师',r.rname as '课程' , AVG(score) as '平均分'
from sc,
(select  t.tname,c.cno as rcso,c.cname as rname
from teacher t ,course c
where t.tno=c.tno)r
where sc.cno=r.rcso
group by sc.cno,r.tname,r.rname 
order by AVG(score) desc

120、查问如下课程问题均在第 3 名到第 6 名之间的学生的问题：-- [学生 ID],[学生姓名], 企业治理, 马克思,UML, 数据库, 均匀问题
select top 6 max(a.sno) 学号, max(b.sname) 姓名,
max(case when cno = 1 then score end) as 企业治理,
max(case when cno = 2 then score end) as 马克思,
max(case when cno = 3 then score end) as UML,
max(case when cno = 4 then score end) as 数据库,
avg(score) as 平均分
from sc a, student b
where a.sno not in 

(select top 2 sno from sc where cno = 1 order by score desc)
  and a.sno not in (select top 2 sno from sc where cno = 2 order by scoredesc)
  and a.sno not in (select top 2 sno from sc where cno = 3 order by scoredesc)
  and a.sno not in (select top 2 sno from sc where cno = 4 order by scoredesc)
  and a.sno = b.sno
group by a.sno

在 Mysql 中，一个用户下能够创立多个库：

而在 Oracle 中，Oracle 服务器是由两局部组成

数据库实例【了解为对象，看不见的】
数据库【了解为类，看得见的】

一个数据库实例可领有多个用户，一个用户默认领有一个表空间。

表空间是存储咱们数据库表的中央，表空间内能够有多个文件。

当咱们应用 Oracle 作为咱们数据库时，咱们须要指定用户、表空间来存储咱们所须要的数据！

既然都浏览到这里了，就点个赞吧！作为浏览福利小编整顿了数据库相干的面试题 + 外围知识点，须要的点击此处

正文完

java

发表至： java

2021-07-01

0

关于java:原创Spring-Boot集成Mybatis的玩法

关于java:Java基础语法六

关于java:探究Spring中Bean的线程安全性问题

关于java:多账号统一登陆怎么实现

关于python:python-办公自动化-1-文件自动化处理

关于java:开发者进阿里必看的30道经典数据库面试题附详细解析

什么是存储过程？有哪些优缺点？

三个范式是什么

什么是视图？以及视图的应用场景有哪些？

drop、delete 与 truncate 别离在什么场景之下应用？

索引是什么？有什么作用以及优缺点？

rowid 特点

索引特点

什么是事务？

事务隔离级别

数据库的乐观锁和乐观锁是什么？

超键、候选键、主键、外键别离是什么？

SQL 束缚有哪几种？

数据库运行于哪种状态下能够避免数据的失落？

Mysql 存储引擎

MyIASM 和 Innodb 两种引擎所应用的索引的数据结构是什么？

varchar 和 char 的区别

mysql 无关权限的表都有哪几个

数据表损坏的修复形式有哪些？

MySQL 中 InnoDB 引擎的行锁是通过加在什么上实现

数据库优化的思路

SQL 优化

①抉择最有效率的表名程序

②WHERE 子句中的连贯程序

③SELECT 子句中防止应用 * 号

④用 TRUNCATE 代替 DELETE

⑤多应用外部函数进步 SQL 效率

⑥应用表或列的别名

⑦多应用 commit

⑧善用索引

⑨SQL 写大写

⑩防止在索引列上应用 NOT

①①防止在索引列上应用计算

①②用 >= 代替 >

①③用 IN 代替 OR

①④总是应用索引的第一个列

数据库构造优化

服务器硬件优化

SQL 练习题

Oracle 和 Mysql 的区别

最初

站内搜索

①②用 `>=` 代替 `>`