5 数据库

选 C。这道题考数据库最基础的概念：数据模型按“怎么表达实体和联系”分成四类。

C 关系模型：用二维表格表达，一张表就是一个“关系”，行叫元组，列叫属性。这是当前主流数据库（MySQL、Oracle、SQL Server）采用的模型。

A 层次模型：用树形结构表达，一个父节点可以有多个子节点，但一个子节点只能有一个父节点，典型代表是 IBM 的 IMS。

B 网状模型：用图结构表达，一个节点可以有多个父节点，比层次模型灵活，但结构复杂、导航困难。

D 面向对象模型：用对象、类、继承表达，能直接存复杂类型，但查询语言不统一。

题干“二维表格结构”是关系模型的专有描述，其余三种都不是表格。四种模型的演进线索是：层次（树）→ 网状（图）→ 关系（表）→ 面向对象（对象）。

选 B。三级模式与三个层级的对应关系是固定的：

外模式（子模式、用户模式）→ 视图。它是用户看到的那部分数据，同一个数据库可以有多个外模式，每个用户只看自己需要的部分。

模式（概念模式、逻辑模式）→ 基本表。它是全体数据的逻辑结构，一个数据库只有一个模式。

内模式（物理模式、存储模式）→ 存储文件。它描述数据在磁盘上怎么存（文件组织、索引、压缩），一个数据库只有一个内模式。

题干顺序是“外、模、内”，对应“视图、基本表、存储文件”，正是 B。A 把顺序反了，C、D 是打乱后的组合。

记忆线索：从用户往里看是“视图 → 基本表 → 存储文件”，从里往外看是“磁盘 → 逻辑 → 用户”。

选 D。题干把三个概念的顺序换成了“视图、存储文件、基本表”，对应关系是：

视图 → 外模式（用户视角）

存储文件 → 内模式（物理存储）

基本表 → 模式（逻辑结构）

所以是“外模式、内模式、模式”，选 D。

A 把视图说成模式、存储文件说成内模式、基本表说成外模式——三处全错位。B 是“外、模、内”，那是真题 2 的顺序，本题题干调换了。C 把视图说成模式、存储文件说成外模式，也错。

这类题的唯一解法是先把对应关系默念一遍（视图=外、基本表=模、存储文件=内），再按题干顺序去对，不要被选项的排列带偏。

选 D。两级映像各管一个独立性，方向不能颠倒：

模式／内模式映像 → 物理独立性。存储结构变了（换磁盘、加索引、改文件组织），只要改这个映像，逻辑模式不用动，应用程序更不用动。

外模式／模式映像 → 逻辑独立性。逻辑结构变了（加字段、拆表），只要改这个映像，外模式（视图）保持不变，应用程序就不用改。

题干问“物理独立性和逻辑独立性分别通过修改什么完成”，顺序是物理在前、逻辑在后，所以答案是“模式/内模式映像、外模式/模式映像”，D。

A、B、C 都把映像和独立性错配了。记忆方法：物理靠内（模式-内模式），逻辑靠外（外模式-模式）。

选 B。题干考的是“映像的名字本身就说明了它连接哪两端”。

模式／内模式映像，名字里的两个词就是它的两端：概念模式（模式）和内模式。所以 B 说“实现了概念模式到内模式之间的相互转换”，完全正确。

A 错在“外模式到内模式”——那要跨过模式，不存在这样的直接映像。

C 错在名实不符：名称是“外模式／模式”，说的却是概念模式到内模式。

D 错在“外模式／内模式的映像”——这个映像根本不存在。两级映像只有外模式/模式、模式/内模式这两个。

这道题是纯概念辨析，把两个映像的名字和两端背清楚，四个选项一眼可破。

这道题的选项在原卷里是关系代数表达式，图片转换时丢失，只剩 A/B/C/D 的位置。这里把判断方法讲清楚，对照任一版真题图都能做。

（55）题干给的是 π_3,4,5(σ_1<6(R×S))，读法是“先做 R×S，再挑第 1 列小于第 6 列的行，最后取第 3、4、5 列”。

所谓“等价”，是把“选择”和“投影”换一种顺序或写法，结果集不变。常用等价变换有两条：① 选择可以下推到笛卡尔积之前（先筛后连，结果一样但更快）；② 投影可以先去掉不参与比较的列。四个选项里只有一项在语义上完全等价，答案是 B。

（56）自然连接的列数 = R 的列数 + S 的列数 − 同名属性个数。按图示算下来是 3 列；元组个数要看同名属性上能匹配上的组合，图中有 2 个元组能配上，所以是“3 和 2”，选 B。

提醒：这类题必须对着图数，文字没法替你数。做法是先列出 R、S 的属性名，圈出同名的那几个，再逐行比对能不能配上。

选 B。这题的关键是数清 R×S 之后每一列是谁。

R 的属性是 A、B、C，S 的属性是 C、D、E。做笛卡尔积后列的顺序是：第 1 列 R.A、第 2 列 R.B、第 3 列 R.C、第 4 列 S.C、第 5 列 S.D、第 6 列 S.E。

题干的 σ_3<6 就是“第 3 列小于第 6 列”，即 R.C < S.D——注意比较的两列恰好都叫 C/D 但分属两表。

A 错：只写 π_A,C,E，没有区分 C、E 来自哪张表。两张表都有 C，不写前缀就产生歧义。

C 错：写成 S.C、S.E，把 R 的 C 换成了 S 的 C。

D 错：写成 R.A、R.C、R.E，但 R 根本没有 E 属性（E 在 S 里）。

只有 B 的 π_A,R.C,E(σ_R.C<S.D(R×S)) 既标清了 C 的来源，又用对了比较条件。

（52）选 C。σ 是选择（按条件挑行），π 是投影（按属性挑列）。π_A,C(σ_A=1∧C=3(R)) 先挑行再挑列，是两者的组合。

A 只说了选择，漏了投影；B 只说了投影，漏了选择；D 连接运算需要两张表，本题只有 R 一张。所以 C 正确。

（53）选 A。执行顺序由内到外：先在 R 中挑出 A=1 且 C=3 的元组（行），再从这些行里取 A、C 两列。所以结果集是“属性 A 和 C 的值分别等于 1 和 3 的元组”。

B 错在“两列为结果集”——结果是元组的集合，不是列的集合。C 错在把“选择”说成“投影”。D 漏掉了 A=1、C=3 这个筛选条件，只描述了投影。

（51）选 C。笛卡尔积的列数 = 两表列数之和。R1 有 3 列、R2 有 3 列，3 + 3 = 6，所以结果是 6 元关系。

（52）选 C。笛卡尔积的元组数 = 两表元组数之积。按图示两表各有若干行，乘起来是 6 个元组。

这两个公式要分清：列相加、行相乘。很多人在这一步记反，把列也乘起来，就会选到 9 之类的错误答案。

对比记忆：自然连接是“列相加再减去同名属性个数”，元组数要看匹配情况，不能简单相乘——这是笛卡尔积与自然连接最关键的区别。

（54）选 C。自然连接的列数 = R 列数 + S 列数 − 同名属性个数。R(A,B,C,D) 4 列，S(A,C,E,F) 4 列，同名的是 A、C 两个，所以 4 + 4 − 2 = 6 列。

（55）选 B。自然连接展开成“笛卡尔积 + 同名属性相等 + 投影去重”，R×S 共 8 列，顺序是：1=R.A、2=R.B、3=R.C、4=R.D、5=S.A、6=S.C、7=S.E、8=S.F。

要写的条件是：R.A=S.A（第 1 列 = 第 5 列）、R.C=S.C（第 3 列 = 第 6 列），再加上题干要求的 R.B > S.E（第 2 列 > 第 7 列）。投影取 1,2,3,4,7,8 列——正好是 R 的全部 4 列加上 S 的 E、F，去掉了重复的 A、C。这正是 B 的写法。

A 错：只写 σ_2>7，漏掉同名属性相等的条件，那只是笛卡尔积上的选择，不是自然连接。C、D 把数字当成字符串比较（'7'），类型不对。

这题的选项在原卷里是四个关系代数表达式，图片转换时丢失了内容。但判断标准很明确，记住就能做。

题干要求：查询 B='大数据' 且 F='开发平台'，结果列为 A、B、C、F，问哪个表达式效率最高。

关系代数优化的核心规则是“选择尽可能下推、投影尽可能早做”：

① 先把 B='大数据'、F='开发平台' 的选择操作下推到连接之前，参与连接的元组数量立刻减少；

② 投影只保留最终需要的 A、B、C、F，减少中间结果的宽度；

③ 连接放在选择之后、投影之前。

四个选项的差别就在这三步的顺序：先 σ 后 ⋈、并且尽早 π 的那个最优，答案是 D。

反过来，如果某个选项先做笛卡尔积再筛，中间结果会膨胀到两表行数的乘积，效率最差。这就是“为什么要下推选择”的直观理由。

（55）选 B。自然连接列数 = 4 + 3 − 2 = 5。R(A,B,C,D) 与 S(C,D,E) 的同名属性是 C、D 两个，减掉后剩 5 列：R.A、R.B、R.C、R.D、S.E。

（56）选 B（原选项为公式图）。把自然连接展开，要满足三个条件：

① 先做 R×S，共 7 列：1=R.A、2=R.B、3=R.C、4=R.D、5=S.C、6=S.D、7=S.E；

② 补上同名属性相等的条件 R.C=S.C（第 3 列 = 第 5 列）、R.D=S.D（第 4 列 = 第 6 列）；

③ 投影去掉重复列，取 1,2,3,4,7。

判断等价式的诀窍：看它有没有写全这两个相等条件，投影有没有去掉 S.C、S.D。少写一个条件就成了普通连接，多留一列就多出重复属性。

选 B。自然连接的规则是“同名属性只保留一份”，所以要先把两边的属性列出来对照。

R(A,B,C,D,E) 和 S(A,C,E,F,G)：同名的有 A、C、E 三个。

结果集 = R 的全部 5 列（A、B、C、D、E）+ S 中不重名的列（F、G）= 7 列。

C 错：列了 R 的 5 列又加上 S.A、S.C、S.E，等于同名属性保留两份，那是笛卡尔积的做法。

D 错：把 S 的全部 5 列都列上，同样重复。

A 错：只列了 A、C、E 三对，既漏了 B、D，又把重名的列重复列出。

速算公式：列数 = R 列数 + S 列数 − 同名属性个数 = 5 + 5 − 3 = 7。算完再核对具体是哪几列，双保险。

（54）选 B。自然连接要求同名属性值相等才能拼上。R 和 S 各有一个同名属性，逐行比对：

R 的 (2,1) 与 S 的 (4,8) 在同名属性上相等 → 拼成 (2,1,4,8)；

R 的 (3,4) 与 S 的 (4,4) 相等 → 拼成 (3,4,4,4)。

所以结果集是这两行，B 正确。A 少了 S 侧的两列，C、D 的行数不对。

（55）选 B（2,2,6）。三种外联接的规则是：

左外联接保留左表全部元组，右表匹配不上就补空值；右外联接保留右表全部元组；完全外联接两边都保留，匹配不上的各自补空。

按图示，左外、右外各得到 2 个元组，完全外把两边未匹配的都保留，共 6 个，所以是 2、2、6。

这类题一定要动手画：把两表的行编号，一条条连，比空想可靠得多。

（54）选 B。题目要求投影 R.A 与 S 的两个属性，正确组合是 R.A、S.B、S.E。

A 错：取了 S.F，题干要的是 S.E。C 错：取了 S.E、S.F，多了一列。D 错：取的是 S.B、S.F，同样没有对上表达式。

这类“选列”题的做法：把表达式里 π 后面的属性逐个写下来，再到选项里逐字比对，包括表名前缀。

（55）选 A。连接条件是 R.B = S.B，而且连接条件必须写在 WHERE 子句里。

B、D 用了 HAVING。HAVING 只能跟 GROUP BY 搭配，用于分组之后的过滤；本题没有分组，用 HAVING 语法上就不成立。

C 写成了 R.B = S.E，把 S 的 B 换成了 E，条件错了。

SQL 的执行顺序记一下：FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY。WHERE 过滤行，HAVING 过滤组，位置不能互换。

选 C。自然连接的属性列数只跟两表的属性名有关，跟数据无关。

R(A,B,C,D,E) 有 5 列，S(B,C,F,G) 有 4 列，同名属性是 B、C 两个。

结果列数 = 5 + 4 − 2 = 7。

D 错：9 是直接相加（5+4），忘了减掉重复的同名属性，那是笛卡尔积的列数。

A 错：5 只取了 R 的列。B 错：6 少算了一列。

这个公式在本章会反复用到（真题 10、12、13、17 都考），值得单独记住：自然连接列数 = 左列数 + 右列数 − 同名属性个数。

顺带对比：笛卡尔积“列相加不减”，自然连接“列相加再减重名”，等值连接“列相加不减、但按条件筛行”。

（52）选 A。表达式要投影 R.A、R.B 和 S.F。

B 错：B 是 R 的属性，写成 S.B 就指错了表。C 错：取了 S.E，题干没要这一列。D 错：取了 S.B、S.F，把 R.B 换成了 S.B。

（53）选 A。R 和 S 的同名属性有 B、C 两个，自然连接要求两个都相等，所以条件必须用 AND 连接：R.B=S.B AND R.C=S.C。

B 错：写成交叉相等（R.B=S.C），把两张表的属性配错了对。

C、D 错在用 OR。OR 表示“只要一个相等就算匹配”，会把大量不该连的行也连上，结果集远比自然连接大。

记住：自然连接的多个同名属性之间是“且”的关系，必须全部相等才能拼接。

选 C。这道题问“哪个表达式效率最高”，考的是关系代数的启发式优化规则。

核心原则只有一条：尽早减小中间结果的数据量。具体到本题有两个动作：

① 选择下推：把 B='信息'、E='北京' 两个条件分别下推到 R 和 S 上，先把不符合的行筛掉；

② 连接：用筛完的小结果集做连接，中间结果规模大幅缩小；最后投影出 A、B、E。

A“先连接后选择”最差：连接尤其笛卡尔积会产生大量中间元组，然后再筛，白白浪费。

B“先投影后连接”有问题：投影可能把连接要用的属性去掉，导致无法连接。

D“先选择后连接并投影”看起来更全面，但“并投影”意味着连接前就投影，同样有丢属性的风险，官方答案取更纯粹的 C。

这条规则在实际数据库里叫“查询重写”，是优化器做的第一件事。

（53）选 B。主键要能唯一确定一行。题干说“同一种零件可由不同供应商供应”，意味着零件号单独不能唯一确定——同一个零件号会出现在多个供应商的行里。必须加上“供应商”，(零件号, 供应商) 才能唯一确定一行。

A 错：(零件号, 零件名称) 里零件名称依赖零件号，等于没加新信息。C 错：供应商所在地依赖供应商，冗余。D 错：漏了零件号，同一供应商供多种零件就分不开了。

（54）选 A。要按零件统计，SELECT 后面先写分组依据“零件名称”（与零件号一一对应），再写聚合：AVG(单价) 求平均，MAX(单价)−MIN(单价) 求极差。

C、D 错在函数写法：“AVG单价”“MAX单价”不是合法语法，聚合函数必须带括号包住列名。B 错在按供应商分组，与题干“各种零件”不符。

（55）选 D。按零件统计就要 GROUP BY 零件号。A、C 按供应商分组，分错对象；B 是排序不是分组，ORDER BY 不能替代 GROUP BY。

三空其实是一条链：分组依据（零件号）→ 聚合列（AVG/MAX/MIN）→ GROUP BY 子句，三者必须一致。

（55）选 A。SQL 里给列起别名的语法是 表达式 AS 别名，顺序不能反。正确写法：AVG(库存量) AS 平均库存量, MAX(库存量)−MIN(库存量) AS 差值。

B、D 错在把顺序写反了（平均库存量 AS AVG(库存量)），语法上不成立。C 错在函数少了括号，“AVG库存量”不是函数调用。

（56）选 D。题干要“查询各种零件的……”，分组依据是零件，所以 GROUP BY 零件号。

A、C 按供应商分组，分错对象；B 是 ORDER BY（排序），不能代替分组。

本题和真题 20 是同一张零件表、同一套聚合，只是把“单价”换成了“库存量”。两题连做一遍，GROUP BY 的用法就固化了。

（56）选 A。要算平均工资和极差，写成 AVG(工资) AS 平均工资, MAX(工资)−MIN(工资) AS 差值。B、D 把别名和表达式写反，C 的“ANY”不是聚合写法。

（57）选 C。两张表靠身份证号关联（这是它们的公共属性），同时还要限定“在读研究生”。两个条件必须同时成立，用 AND：Students.身份证号=Teachers.身份证号 AND Students.类别='研究生'。

A 漏了类别过滤，会把所有教师都算进来。B 漏了连接条件，两表不做连接会变成笛卡尔积。D 用 OR，只要满足一个就入选，结果完全失控。

（58）选 D。学生侧的条件是“女研究生”：性别='女' AND 类别='研究生'。字符串必须加单引号，A、B、C 都没加——数据库会把“女”当成列名而不是值。

（59）选 A。教师侧的条件是工资不低于 3500：工资>=3500。工资是数值型，不能加引号——加了引号就变成字符串比较，'3500' 与数字的比较规则不同，结果可能出错。

四空连起来是一条完整查询：聚合列 → 连接＋过滤 → 学生侧条件 → 教师侧条件。第（58）（59）两空专考“字符串加引号、数值不加引号”，这是 SQL 里最常扣分的细节。

（54）选 A。要按部门统计平均工资，SELECT 后面先写分组依据“部门”，再写聚合 AVG(应发工资) AS 平均工资。

B 错：按姓名分组没有意义，每个人一行，算不出部门平均。C、D 错在别名写法反了。

（55）选 D。按部门统计就要 GROUP BY 部门。A、B 是 ORDER BY（排序），C 按姓名分组，都不对。

（56）选 C。这是本题的核心考点：分组后的过滤必须用 HAVING，不能用 WHERE。

A、B 用 WHERE 直接跟聚合函数 COUNT(...)，语法上就不允许——WHERE 在分组之前执行，那时还没有“组”，算不出 COUNT。

D 用 HAVING 是对的，但条件写成 COUNT(DISTINCT(部门))>2，数的是“不同部门的个数”，而题干要的是“部门里的人数”，所以错。

记牢执行顺序：FROM → WHERE（筛行）→ GROUP BY（分组）→ HAVING（筛组）→ SELECT → ORDER BY。

（54）选 A。联系类型看三个实体之间的基数：

一个供应商可以给多个项目供多种零件；一个项目可以由多个供应商供多种零件；一种零件也可以由多个供应商供给多个项目。三方都是多对多，所以是 *:*:*。

B、C、D 都把某一方限定成了“1”，与题干“至少供应 3 个项目”矛盾——如果供应商对项目是 1 对多，就不存在“供应 3 个项目”的统计需求了。

（55）选 D。要统计“供应商供应了多少”，数据在联系表 SP_P 里（供应商号、项目号、零件号、数量）。从 Supp 或 Proj 出发都拿不到数量。

（56）选 C。两层判断：① 分组后过滤用 HAVING，B、D 的 WHERE 排除；② “至少 3 个项目”要数不重复的项目号，因为同一供应商可能给同一个项目供多种零件，不去重会重复计数，所以用 COUNT(DISTINCT 项目号) > 2（“至少 3”即“大于 2”）。

A 漏了 DISTINCT，会把同一项目的多条记录重复计入。

（51）选 D。GRANT 的完整语法是：GRANT 权限 ON 对象类型 对象名 TO 用户。

所以“INSERT 权限”要写成 INSERT ON TABLE Students——INSERT 后面必须跟 ON。

A、C 都缺了 ON，语法不完整。B 写了 ON，但权限写成了 UPDATE，与题干“插入权限”不符。

（52）选 D。“允许转授”在 SQL 里就是 WITH GRANT OPTION——拿到权限的人可以再把这个权限授给别人。

A“FOR ALL”是对所有用户，不是转授。B“PUBLIC”表示授给所有用户，语义完全不同。C“WITH CHECK OPTION”是视图的检查约束，与授权无关。

这两个选项名字很像，一定要分清：GRANT OPTION 管“能不能转授”，CHECK OPTION 管“数据合不合条件”。

选 B。DBMS 的授权功能解决的是“谁能访问什么”，属于安全性范畴。

B 安全性：防止未授权用户访问、修改数据，手段包括用户认证、权限授予、视图隔离、审计日志。DBA 给不同用户授不同权限，正是安全性的核心机制。

A 正确性：不是数据库的标准术语，一般指数据符合业务规则，属于完整性的范畴。

C 一致性：指事务执行前后数据库都处于合法状态（比如转账前后总额不变），由事务的原子性和隔离性保证。

D 完整性：指数据的正确性和相容性，靠主键、外键、CHECK 约束、非空约束保证，管的是“数据本身合不合法”，不是“谁能访问”。

一句话区分：安全性管“谁能进门”，完整性管“进门的数对不对”，一致性管“一次操作前后账平不平”。

选 C。题干最后一句“并允许转授”就是直给提示——SQL 里用 WITH GRANT OPTION 表示获得权限的用户可以把这个权限再授予他人。

A“FOR ALL”表示对所有用户生效，不是转授权限。B“CASCADE”是级联选项，用在 DROP 或外键定义里（级联删除／更新），与授权无关。D“WITH CHECK OPTION”是视图的检查约束。

还要注意本题的一个细节：权限写成了 UPDATE(name)，这是列级授权——只授予对 name 这一列的修改权限，而不是整张表。SQL 支持列级授权，写法就是把列名放在权限后面的括号里。

和真题 25 对照：那道授的是整表 INSERT，这道授的是单列 UPDATE，但“允许转授”的写法完全一样。

（55）选 B。创建视图的语法是 CREATE VIEW 视图名 AS SELECT ...，所以是 VIEW Computer-BOOK。

A 错：CREATE TABLE 是建基本表。C、D 把关键字放在名字后面，语法不成立——SQL 里对象类型必须写在对象名之前。

（56）选 C。题干要求“修改、插入时保证视图只有计算机类图书”，这正是 WITH CHECK OPTION 的作用：它会检查通过视图执行的 INSERT／UPDATE 是否满足视图的 WHERE 条件（图书类型='计算机'），不满足就拒绝。比如往这个视图里插一本“文学”类的书，会被直接挡回去。

A“FOR ALL”、B“PUBLIC”与视图约束无关。D“WITH GRANT OPTION”是授权转授，不是数据校验。

这题和真题 25、27 组成一组：三题都在四个相似选项里选，考的就是 GRANT OPTION 与 CHECK OPTION 的区别。

选 D。视图的本质是虚拟表：数据库里只保存它的定义（一条 SELECT 语句），不保存数据。每次查询视图，实际上是现场执行那条 SELECT。

D 正确：视图是虚拟表，数据可以来自一个或多个基本表，也可以来自其他视图（视图嵌套）。

A、B 都错在“真实存在的表”。视图不占数据存储空间，这是它和基本表最根本的区别。

C 错在“只能从一个基本表中导出”。多表连接、聚合、子查询都可以定义视图，这是视图的常规用法。

视图的价值有三个：① 简化复杂查询；② 做权限隔离（只让用户看视图，不给基本表权限）；③ 提供逻辑独立性（基本表结构变了，改视图定义即可，应用程序不用动）。

选 D（2017 下）／选 C（2021 下，选项顺序不同）。结论只有一个：聚簇索引改变的是内模式。

原因：聚簇索引（clustered index）会把表中的数据行按索引键的物理顺序重新组织存储——索引和数据是同一份，叶子节点就是数据页。这改变的是数据在磁盘上的存放方式，属于物理存储层面，也就是内模式。

A 用户模式、B 外模式：都是用户视角，与存储顺序无关。C 模式：描述逻辑结构（有哪些表、哪些列），不涉及数据怎么排。

对照记忆：建索引、改存储结构 → 内模式；建视图 → 外模式；建表、改表结构 → 模式。

两个年份考同一道题但选项顺序不同，只要记住“聚簇索引＝物理存储＝内模式”这个对应，选项怎么排都不影响。

（55）选 D。用闭包法求候选键。U={A,B,C}，F={AB→C, C→B}。

先看孤立属性：A 只出现在 AB→C 的左边，从没出现在任何依赖的右边，A 必须进候选键。

试 AB：(AB)+ —— AB→C 得 C，所以 {A,B,C} = U，AB 是候选键。

试 AC：(AC)+ —— C→B 得 B，再 AB→C 得 C，所以 {A,C,B} = U，AC 也是候选键。

所以有 2 个候选键：AC 和 AB。

C 错在把 BC 当候选键，但 (BC)+ = {B,C}，推不出 A。A、B 都只说了一个候选键，漏了另一个。

（56）选 C。主属性的定义是“包含在任何一个候选键中的属性”。

AB 含 A、B；AC 含 A、C。合起来 A、B、C 三个属性全部出现在某个候选键里，所以3 个都是主属性，非主属性 0 个。

A、B、D 分别说 1 个、2 个、3 个非主属性，都不对。

这题和真题 34（2016 上半年）是同一道题的原样重考，答案都是“2 个候选键 + 0 个非主属性”。看到 U 只有 3 个属性、依赖是 AB→C 和 C→B 这个组合，直接锁定 D、C。

选 C。求候选键的标准方法是闭包法：找出从没出现在任何函数依赖右边的属性，它一定属于候选键；再逐步求闭包，看能不能推出全部属性。

本题 F={A→B, A→C, C→D, AE→H}，U={A,B,C,D,E,H}。

第一步看“只出现在左边”的属性：E 只出现在 AE→H 的左边，从没出现在任何右边，所以 E 必须进候选键。

第二步求 AE 的闭包：AE 出发，A→B 得 B；A→C 得 C；C→D 得 D；AE→H 得 H。所以 (AE)+ = {A,E,B,C,D,H} = U，AE 能推出全部属性，是候选键。

A 错：AC 推不出 E 和 H，缺两列。B 错：AB 同样缺 E、H。D 错：DE 缺 A，推不出 B、C。

这类题的关键动作是“先找孤立属性、再求闭包验证”，比一个个试快得多。

选 A。全码（All-Key）的定义是：关系的全部属性共同构成候选键，任何一个真子集都不能唯一确定元组。

R(H,L,M,P) 有 4 个属性，如果是全码，主键就是 HLMP 这个整体。

B 错：任选一个属性作主键，那是“每个属性都能决定全部”的极端情况，不是全码。C、D 错：任选两个或三个，同样违背“全部属性才够”的定义。

全码是范式理论里的一个特殊情形：所有属性都是主属性，没有非主属性。因为没有非主属性，就不存在“非主属性对码的部分依赖和传递依赖”，所以全码关系一定属于 BCNF。

现实中全码很少见，它更多是理论上的边界情形，用来考“主属性／非主属性”的概念。

选 B。U={A,B,C}，F={AB→C, C→B}，用闭包法逐个验证：

先看孤立属性：A 只出现在 AB→C 的左边，从没出现在右边，所以 A 必须进候选键。

试 AB：(AB)+ —— AB→C 得 C，于是 {A,B,C} = U，AB 是候选键。

试 AC：(AC)+ —— C→B 得 B，再 AB→C 得 C，于是 {A,C,B} = U，AC 也是候选键。

所以有两个候选键：AB 和 AC。

再看主属性：出现在任一候选键里的属性都是主属性。AB 含 A、B，AC 含 A、C，合起来 A、B、C 全是主属性，非主属性 0 个。

A 错：候选键写成 AC 和 BC，但 (BC)+ = {B,C}，推不出 A。C、D 错在只说了一个候选键，漏了另一个。

这题最容易错的地方是“候选键可能不唯一”——很多人找到一个就停了。

这道题的题干和选项在原卷里带具体属性集与函数依赖，转换时丢失了公式，这里把两个空的判断方法讲透。

（52）求主键（候选键）的标准步骤：

① 找出只出现在函数依赖左边的属性——它不能被别人推出，必须进候选键；

② 找出从没出现在任何依赖里的属性——同样必须进候选键；

③ 把这些必选属性组成集合求闭包：能推出全部属性，它就是候选键；推不全，就往里补属性再试。

答案 A。

（53）判断冗余函数依赖的方法是“逐一去除法”：对 F 中每一条依赖 X→Y，先把它从 F 里拿掉得到 F'，再求 X 在 F' 下的闭包。如果闭包仍包含 Y，说明这条依赖能由其他依赖推出，它是冗余的；否则是必要的。

直观例子：F={A→B, B→C, A→C}，其中 A→C 就是冗余的——去掉它之后，用 A→B、B→C 仍能推出 A→C。

选 A。题干问“各候选关键字中必定含有”的属性，判断方法只有一条：

只出现在函数依赖左边、从不出现在任何依赖右边的属性，一定属于每一个候选键。

理由：候选键必须能推出全部属性。一个属性如果能被别的属性推出来，它就不必出现在候选键里；反过来，一个属性如果从来不能被推出，那只能由它自己“自带”，所以任何能推出全部属性的属性组都必须包含它。

本题 A 就是这样的属性。B、C、D 都出现在某条依赖的右边（能被推出），因此不是“必定含有”。

这个判断在求候选键时是第一步，也是最省时间的一步——先锁定必选属性，再求闭包，比盲目枚举快得多。

两空的选项在原卷中是具体的属性组合，转换时丢失了内容，这里讲判断方法。

（52）问候选键有几个，答案是 C（2 个）。做法：① 锁定必选属性（只出现在左边的）；② 求它的闭包看能否推全；③ 推不全就逐个补充属性再试；④ 每找到一个能推全全部属性的最小集合，就是一个候选键。

要注意“最小”：如果 {A,B} 是候选键，{A,B,C} 就不是——它含有多余属性，那是超键而不是候选键。

（53）问“候选键中必定含有”哪个属性，答案就是那个只出现在依赖左边的属性。它无法被任何其他属性推出，所以任何候选键都必须带上它。

同时它一定是主属性——主属性的定义就是“包含在某个候选键中的属性”。这两个概念常一起考，别混：主属性说的是“在不在某个键里”，候选键说的是“能不能推出全部”。

（52）选 A。两个关系分别求闭包：

R：Fr={A→BC, B→D}。A→BC 拆开就是 A→B、A→C；再由 B→D 得 D。所以 (A)+ = {A,B,C,D} = U，A 是主键。

S：Fs={A→C, C→E}。A→C，再 C→E 得 E。所以 (A)+ = {A,C,E} = U，A 也是主键。

两个主键都是 A，选 A。B、D 都多带了 B；C 多带了 C。

（53）选 C。要判断“传递依赖”，看有没有 X→Y、Y→Z 的链条，且 Y 不能反推 X、Z 不属于 Y：

R 中：A→B，B→D，且 B 推不出 A、D 不在 B 里 → A→D 是传递依赖。

S 中：A→C，C→E，同样条件满足 → A→E 是传递依赖。

所以两个关系都存在传递依赖，C 正确。

A 错：只承认 Fr 蕴含 A→B、A→C，却否认 Fr 有传递依赖。B 错：承认 Fs 有、否认 Fr 有，只对了一半。D 与 B 相反，同样只对一半。

选 C。两步走：先定候选键，再找传递依赖。

第一步求候选键：F={A→BC, AC→D, B→D}。A→BC 拆成 A→B、A→C；既然 A 已经能定 C，AC→D 就等价于 A→D。所以 (A)+ = {A,B,C,D} = U，候选键是 A。

第二步找传递依赖：A→B，B→D，且 B 推不出 A、D 不在 B 里 → A→D 是传递依赖。

所以“存在传递依赖 A→D，候选键是 A”，选 C。

A 错：说“不存在传递依赖”，但 A→B→D 这条链是明摆着的。B 错：候选键不是 AC，A 单独就够了。D 错：候选键不是 C，B→D 也不是传递依赖（B 不是键）。

补充一句：存在传递依赖说明 R 只达到 2NF，没到 3NF。范式判断和依赖判断是同一件事的两面。

（52）选 C。U={A,B,C,D,E,H}，F={A→B, B→DH, A→H, C→E}。

先找必选属性：C 只出现在 C→E 的左边，从没在右边出现，C 必须进候选键；A 同样只出现在左边，A 也必须进。

求 AC 的闭包：A→B 得 B；B→DH 得 D、H；A→H（冗余但也成立）；C→E 得 E。所以 (AC)+ = {A,B,C,D,E,H} = U，AC 是候选码。

再看 A 单独行不行：A 能推出 B、D、H，但推不出 C 和 E，所以 A 不是候选码。因此只有 AC 一个候选码，选 C。

（53）选 D。这里有两件事：

传递依赖：A→B，B→D，得 A→D；A→B，B→H，得 A→H。这两条都是传递依赖。

冗余依赖：F 里已经直接写了 A→H，而它又能由 A→B→H 推出来——用“逐一去除法”去掉 A→H，剩下的依赖仍能推出它，所以 A→H 是冗余的。

两件事同时成立，选 D。A、B 否认传递依赖，C 否认冗余，都不对。

（52）选 A。U={A1,A2,A3,A4}，F={A1→A2, A1→A3, A2→A4}。

A1 只出现在依赖左边，必进候选键。求闭包：A1→A2 得 A2；A1→A3 得 A3；A2→A4 得 A4。所以 (A1)+ = {A1,A2,A3,A4} = U，A1 是候选码。

A1 单独就能推全，不需要再补属性，所以唯一候选码是 A1。B、C、D 都多了属性，是超键而非候选键。

（53）问“错误的”，选 D。逐条验证：

A：A1→A2A3，用合并规则——A1→A2 与 A1→A3 合并即得，成立。

B：A1→A4，用传递规则——A1→A2，A2→A4，成立。

C：A1A2→A4，用增广规则——A2→A4 两边同时加上 A1，成立。

D：A2→A3——A2 只能推出 A4，推不出 A3。A3 只能由 A1 决定，而 A2 推不出 A1。所以这条不成立，选 D。

阿姆斯特朗公理的三条（自反、增广、传递）加上推导出的合并、分解、伪传递规则，是判断“是否被蕴含”的全部工具。

选 A。先定主键，再逐个检查非主属性。

F={零件号→零件名称, (零件号,供应商)→库存量, 供应商→供应商所在地}。

零件号单独推不出供应商，供应商单独也推不出零件号，两者必须组合，所以主键是(零件号, 供应商)。

看非主属性：零件名称、供应商所在地、库存量。

零件名称：只由零件号决定，而零件号只是主键的一部分 → 部分函数依赖。

只要存在部分依赖，就违反 2NF，只满足 1NF。所以选 A。

补充：供应商所在地由供应商决定，而供应商不是候选键 → 还存在传递依赖。这张表两个毛病都有，必须分解。

记忆：1NF 管“原子”，2NF 管“完全依赖”，3NF 管“无传递依赖”，BCNF 管“决定因素都含码”。判断顺序永远是从 1NF 往上逐级查，第一处不满足就是它的级别。

（53）选 A。先定主键：E 和 M 都只出现在依赖左边，必须组合；EM 能推出 N、Q、L，所以主键是 EM。

再看非主属性：N、L、Q。

N：只由 E 决定，E 是主键的一部分 → 部分依赖。

L：只由 M 决定，M 也是主键的一部分 → 部分依赖。

存在部分依赖，2NF 都不到，只满足 1NF。

（54）选 D。范式不够会带来四类问题，本题三个都有：

冗余：同一个 E 的 N 值、同一个 M 的 L 值会重复存储很多遍。

修改不一致：同一个 E 对应多个 N 值，改一处忘了另一处，数据就自相矛盾。

插入异常：想记录一个还没有对应 M 的 E，主键不全，插不进去。

删除异常：删掉最后一条记录，可能把 E 和 N 的对应关系一起删没了。

C 错在“不存在部分函数依赖”——本题恰恰存在两处。A、B 都说“无需分解”，显然不对。

（53）选 B。按闭包法求主键，答案 B（原选项为公式图）。

做法：先锁定只出现在依赖左边的属性，求它的闭包；能推全就是候选键，推不全就补属性。

（54）选 D。“每个非主属性完全函数依赖于主键”正是 2NF 的定义。

A 错：传递依赖是 3NF 的门槛，跟 1NF 无关。1NF 只要求“每个属性都是原子的、不可再分”。

B 错：“不存在传递依赖 ⇒ 2NF”推理方向错了。2NF 看的是有没有部分依赖，与传递依赖无关。

C 错：“存在传递依赖 ⇒ 3NF”完全说反了。3NF 的要求恰恰是不存在非主属性对码的传递依赖。

四级范式的门槛要分清：

1NF：属性原子；2NF：无部分依赖；3NF：无传递依赖；BCNF：每个决定因素都包含码。

判断时从 1NF 逐级往上查，第一个不满足的级别就是答案。

（54）选 D。求 (时间, 学生) 的闭包：

(时间,学生) → 教室（题给依赖）；

(时间,教室) → 课程；

课程 → 教师；

(学生,课程) → 成绩。

一路推下来得到全部属性，所以主键是 (时间, 学生)。

（55）选 B（2NF）。看有没有部分依赖：主键是 (时间, 学生)，非主属性是课程、教师、成绩、教室。每个非主属性都需要“时间”和“学生”共同确定吗？

按题给依赖：教室由 (时间,学生) 决定，课程由 (时间,教室) 决定——都需要主键的两个属性参与，不存在只依赖其中一个的情况，所以没有部分依赖，达到 2NF。

但存在传递依赖：课程→教师，教师由课程决定，而课程不是候选键，所以教师传递依赖于主键。有传递依赖就到不了 3NF，所以最高是 2NF。

（56）选 C（BCNF）。注意这一问问的是R2(学生,课程,成绩) 的规范化程度，不是整个分解结果。

R2 的主键是 (学生, 课程)，唯一的非主属性是成绩，且成绩完全由 (学生,课程) 决定。没有部分依赖、没有传递依赖，而且唯一的决定因素就是主键本身——满足 BCNF。

这题最容易错的是把第（56）空当成“整个分解最高到几 NF”，那样就会选 2NF。读题时要盯住“其中 R2”这几个字。

（52）选 D。这道题和真题 45 完全同构，只是把“课程”换成了“培训科目”。

求 (时间, 学生) 的闭包：(时间,学生)→教室；(时间,教室)→培训科目；培训科目→培训师；(学生,培训科目)→成绩。推全，所以主键是 (时间, 学生)。

（53）选 B（2NF）。主键 (时间, 学生)：

不存在部分依赖——教室、培训科目、成绩、培训师都需要主键的两个属性共同参与才能确定。

存在传递依赖——培训科目→培训师，培训师由培训科目决定，而培训科目不是候选键。

所以达到 2NF，但到不了 3NF。

两道题连着考同一个模型，说明这个“时间+学生”的组合是命题人偏爱的经典案例。记住它的结论：主键 (时间,学生)，最高 2NF，瓶颈在“课程→教师”这条传递依赖。

（55）选 C。题干给了完整的函数依赖集，按闭包法求主键，答案 C（原选项为公式图）。

做法三步：① 找只出现在左边、从不出现的属性，必进候选键；② 求其闭包；③ 推不全就补属性再试，直到能覆盖全部属性。

（56）选 C（3NF）。判断顺序是从低到高逐级查：

先查 2NF：有没有非主属性只依赖主键的一部分？没有部分依赖，才继续往上。

再查 3NF：有没有非主属性依赖另一个非主属性（传递依赖）？如果不存在，就是 3NF。

本题两关都过，所以达到 3NF。

A、B 是没走到这一步；D（BCNF）要求更严——每个决定因素都必须包含码。3NF 允许“主属性对码的传递依赖”，BCNF 不允许，所以过了 3NF 不一定过 BCNF。

一句话区分：3NF 只管非主属性，BCNF 连主属性也管。

（52）选 A（1NF）。EMP 的属性里有“家庭成员”“成员关系”——一名员工可以有多个家庭成员，这意味着这两个属性不是原子的，它们实际上是一组多值。

严格说，1NF 要求每个分量不可再分。这张表把“多个成员”塞进一个字段，形式上做了“第一范式化”的处理（把多值压进一个单元格）才算 1NF，所以答案是 1NF，连 2NF 都谈不上。

（53）选 D。这种大宽表必然带来四类问题：

冗余：部门电话、部门负责人随每个员工重复存储。

修改不一致：部门换了负责人，要改这个部门所有员工的行，漏一行就矛盾。

插入异常：新建一个还没有员工的部门，没有员工号，插不进去。

删除异常：删掉部门里最后一个员工，部门电话、负责人的信息也跟着丢了。

A、B 说“无冗余”，C 说“无修改不一致”，都与事实相反。

（54）选 B。按“一个事实一张表”拆：

EMP1(员工号, 姓名, 部门, 家庭住址)——员工的基本信息；

EMP2(部门, 部门电话, 部门负责人)——部门的信息，主键是部门；

EMP3(员工号, 家庭成员, 成员关系)——员工与家庭成员的一对多关系。

A 错：EMP1 里漏了“部门”，员工和部门的关系就断了。C、D 是其他错误组合。

选 C。分解的原则是“一个函数依赖一张表”，并且每张表的主键要能决定表内所有属性。

原依赖有三组：

① 零件号 → 零件名称；

② 供应商 → 供应商所在地；

③ (零件号, 供应商) → 单价、库存量。

按这三组拆，正好三张表：

P1(零件号, 零件名称)；

P2(零件号, 供应商, 单价, 库存量)——这是“供应”这个事实，主键是两个属性的组合；

P3(供应商, 供应商所在地)。

A 错：把“单价、库存量”放进了供应商表，但单价和库存量是“某供应商供某零件”的属性，只靠供应商定不下来。

B 错：拆成两张表，把“供应商所在地”和“单价、库存量”混在一张表里，主键既不是供应商也不是零件号，语义混乱。

D 错：拆成四张表，把本该在一起的“单价、库存量”又分开了，反而增加了连接成本。

判断分解是否合理，看两条：每张表都有明确的主键；每个非主属性都完全依赖于该表的主键。

（54）选 B。题干说“同一种元件可由不同供应商供应”，意味着元件号单独不能唯一确定一行——同一个元件号会出现在多个供应商的行里。必须加上“供应商”，(元件号, 供应商) 才能唯一确定一行。

A 错：元件名称依赖元件号，等于没加新信息。C 错：供应商所在地依赖供应商，冗余。D 错：漏了元件号。

（55）选 C。按“一个依赖一张表”拆：

元件1(元件号, 元件名称)——对应 元件号→元件名称；

元件2(元件号, 供应商, 库存量)——对应 (元件号,供应商)→库存量；

元件3(供应商, 供应商所在地)——对应 供应商→供应商所在地。

A、B 都把“库存量”错放进了供应商表或只拆成两表，库存量是“某供应商供某元件”的属性，不能只靠供应商决定。

（56）选 C（3NF）。拆完之后逐表检查：

元件1：主键元件号，无部分依赖、无传递依赖，达到 3NF（实际是 BCNF）。

元件2：主键 (元件号, 供应商)，库存量完全依赖主键，无传递依赖，3NF。

元件3：主键供应商，所在地完全依赖，3NF。

三张表都到 3NF，整体就是 3NF。D（4NF）要求消除多值依赖，本题没有多值依赖的场景，到不了也不必要。

选 B。题干要求“分解后保持函数依赖”，判断标准只有一条：

原 F 中的每一条依赖，它的左右属性必须落在同一个子模式里。如果某条依赖被拆到了两个子模式，这条依赖就“丢失”了，分解不保持函数依赖。

本题 F={A→B, A→C, C→D, AE→G}：

A→B、A→C、C→D 这三条彼此关联（A 决定 B、C，C 又决定 D），应该放在同一组；

AE→G 需要 A、E、G 三个属性待在一起。

按这个原则去找选项，答案是 B（原选项为分解公式图）。

反过来检查其他选项：如果某个选项把 A 和 B 分到了两张表，那 A→B 就跨表了，这条依赖无法在单表内用主键/约束表达，属于“丢失依赖”。

要区分两个概念：保持函数依赖看“依赖有没有丢”，无损连接看“分解后能不能还原出原表”。两者是分解的两个独立标准，一个分解可以无损但不保持依赖，也可以保持依赖但有损。

选 D。这类题要分两步判，缺一步都会选错。

第一步判无损连接：把 R 分解成 R1、R2 后，如果 R1∩R2（交集）能函数决定 R1 或 R2 中的一个，分解就是无损的；否则有损。本题的交集推不出任一子模式，所以是有损。

“有损”不是说数据丢了，而是说分解后无法通过自然连接还原出原表——会多出原表里没有的“虚假元组”。

第二步判保持函数依赖：看原 F 里的每条依赖，其左右属性是否都落在同一个子模式中。本题有依赖被拆到了两张表里，所以不保持函数依赖。

两步合起来是“有损连接且不保持函数依赖”，选 D。

A、B 说“无损”，C 说“保持依赖”，都只对了一半或全错。

记忆：无损看交集，保依赖看归属——一个管连接能不能还原，一个管依赖能不能在单表内表达。

（54）选 D。U={A,B,C,D,E}，F={A→B, DE→B, CB→E, E→A, B→D}。

先看必选属性：C 只出现在 CB→E 的左边，从没在右边出现，C 必进候选键。

试 CE：C→（无）；E→A 得 A；A→B 得 B；B→D 得 D；(C,B) 已有 B，CB→E 得 E（已有）。所以 (CE)+ = {C,E,A,B,D} = U，CE 是候选键。

A 错：AB 推不出 C、E。B 错：DE 推不出 C。C 错：DB 推不出 C、E。

（55）选保持函数依赖且无损的那个分解（原选项为分解公式图），答案是 D。判断方法：

无损：看每对子模式的交集能否推出其中一个子模式。比如把 R 拆成 R1、R2，若 R1∩R2 → R1 或 R1∩R2 → R2，则无损。

保持依赖：原 F 的每条依赖，左右属性都要落在同一个子模式里；跨表的依赖就“丢了”。

本题的关键是 A→B、B→D、E→A 这几条要能串起来，CB→E 和 DE→B 也要有落脚点。逐个选项检查这两条，只有 D 同时满足。

（54）选 B。先分清三种特殊属性：

派生属性：可以由其他属性算出来的。年龄能从出生年月和当前日期推算，所以年龄是派生属性——存了它反而可能不一致（比如跨年没更新）。

多值属性：一个实体在该属性上有多个值。“联系方式”记录了手机和办公室电话两个值，属于多值属性。规范做法是把它拆成独立的表。

复合属性：可以再分成子属性，比如“家庭住址”含省、市、街道。

所以是“年龄和联系方式”，选 B。A、C、D 都把出生年月当成了派生或多值属性，但出生年月是基本属性。

（55）选 C。部门号参照 Dept 的主码，这是典型的外键约束——它保证 Emp 里的部门号必须在 Dept 里存在，从而维护参照完整性。

（56）选 C。修改表中已有数据的命令是 UPDATE 表 SET 列=值 WHERE 条件。INSERT 是插入新行，DELETE 是删除行，MODIFY 是改表结构（DDL），都不对。

（52）选 C。“家庭住址”由邮编、省、市、街道四部分组成，可以继续往下拆，所以是复合属性。

A 简单属性：不可再分的属性，比如性别、年龄。B 多值属性：一个实体有多个值，比如多个电话号码。D 派生属性：能由别的属性算出来，比如年龄由出生年月算。

（53）选 D。一名学生可以有多个家庭成员，所以“家庭成员、关系、联系电话”是多值属性。多值属性不能塞在同一张表里（否则要么重复存储学生信息，要么一个字段塞多个值违反 1NF），正确处理是拆成独立实体：家庭成员表（学号, 家庭成员, 关系, 联系电话）。

A 错：说已达 3NF 不用处理，但多值属性本身就违反 1NF。B 错：限制只能记一个亲属，业务上不成立。C 错：增加若干组字段（家庭成员1、家庭成员2……），这是最典型的错误设计——字段数量无法预知，查询也极其别扭。

选 D。同一个对象在不同子系统里叫不同名字（考勤系统叫“员工”、档案系统叫“职工”），这是命名冲突。

命名冲突有两种表现：

异名同义：同一个东西叫不同名字，本题就是这种。

同名异义：不同的东西起了同一个名字，比如两个部门都有“编号”但含义不同。

A 语义冲突：不是 E-R 合并的标准分类。B 结构冲突：指同一对象在不同分 E-R 图里的身份不同——比如这里当实体、那里当属性，或者联系类型不同（一处 1:n、一处 m:n）。C 属性冲突：指同一属性的类型、长度、取值范围不一致，比如“年龄”一处是整数、一处是字符串。

三类冲突的辨别关键：名字对不上是命名，类型/范围对不上是属性，身份/结构对不上是结构。

（51）选 C。人力部门的“职工”和教学部门的“教师”，本质上是同一个对象（人），但在两个子系统中被抽象成了两个不同的实体：键不同（职工号 vs 教师号）、属性集不同（一个有出生日期，一个有职称）。

这属于结构冲突——同一个对象在不同分 E-R 图里的抽象方式不一致。

A 属性冲突：指同一属性的类型、取值范围不同，本题不是。B 命名冲突：指名字不一致，但本题连实体本身都不同，不只是名字问题。D 实体冲突：不是标准分类。

（52）选 B。合并的思路是“以更一般的实体为基础，把特有属性并进来”：

职工是更一般的概念（教师是职工的一种），所以保留职工实体，把教师特有的“职称”属性加进去，然后删掉重复的教师实体。

A 错：各自保持，等于没合并，冗余依旧。C 错：直接删教师实体，把职称信息丢了。D 错：把教师的所有属性（含教师号）都并进来，会引入大量冗余和空值——教师号对非教师职工没有意义。

（51）选 C。逐个看两个联系的基数：

学生—院系：一名学生属于一个院系，一个院系有多名学生 → 1:n（院系是 1 端，学生是 n 端）。

学生—课程：一名学生选多门课，一门课被多名学生选 → m:n。

所以是“1:* 和 *:*”，选 C。A、B、D 都把第二个联系说成了一对多或反过来的多对一。

（52）选 A。1:n 联系在转关系模式时有两种处理：

① 单独建一张表（联系表）；

② 不单独建表，把“1”端的主键作为外键加到“n”端。

本题问的是第二种：院系是 1 端，学生是 n 端，所以把院系的主键（院系号）加到学生表 S 里，选 A。

B 错：C（课程）的主键应该加到选课联系表里，不是加到 S。C、D 把方向搞反了——外键永远加在“多”的那一端。

（51）选 B。一个科室有多名职工，一名职工只属于一个科室 → 1:n（科室是 1 端，职工是 n 端）。

A 错：1:1 要求两边都唯一。C 错：n:1 方向反了——那是“多名职工对应一个科室”从职工侧看，标准写法按“科室:职工 = 1:n”。D 错：m:n 表示一名职工可以在多个科室，与题干矛盾。

（52）选 D。一个医生可看多个病患，一个病患可由多个医生诊治，且“多次诊治” → m:n。

（53）选 C。m:n 联系必须独立成表，主键是双方主键的组合。但题干说“多次诊治”——同一个医生给同一个病患看过多次，光靠（病历号, 职工号）无法区分是哪一次，必须加上就诊时间。所以是“就诊(病历号, 职工号, 就诊时间, 就诊情况)”。

A 错：缺就诊时间，多次就诊会冲突。B、D 错：用“职工姓名”代替“职工号”，姓名可能重名，不能作键。

（54）选 B。主键要能唯一确定一次就诊，所以是“病历号 + 职工号 + 就诊时间”三者的组合。A 少了时间，C、D 用了姓名，都不行。

这四空其实考的是同一件事：联系表的主键 = 双方主键 + 区分多次发生的属性。

选 D。E-R 图转关系模式时，联系的处理规则按基数分三种：

1:1：可以把任一方的主键加到另一方，不必单独建表。

1:n：把“1”端的主键加到“n”端，不必单独建表。

m:n：必须单独建表，表中包含双方的主键（作为外键，同时组合成主键）加上联系自身的属性。

所以选 D：“两方的码加上联系上的属性独立构成一个关系模式”。

A、B、C 都只拿了一方的码。只用一方的码，同一方对应多条联系记录时无法区分，主键不唯一，表就不合法。

举例：学生选课，选课表 = (学号, 课程号, 成绩)，主键是 (学号, 课程号)。学号单独不能作主键——一个学生选多门课；课程号单独也不行——一门课多个学生选。

（54）选 C。两个表做自然连接，列数 = 左列数 + 右列数 − 同名属性个数。

部门表有 3 列（部门代码、部门名称、负责人之类），员工表有 5 列，同名的是“部门代码”1 列，所以 3 + 5 − 1 = 7 列。

A、B 少算了，D 是把同名属性重复保留（那是笛卡尔积的算法）。

（55）选 D。一名员工可以参与多个项目，一个项目有多名员工 → m:n。

（56）选 B。m:n 联系独立成表，主键是双方主键的组合：(项目编号, 员工代码)。

A 错：用了“项目名称”作键，名称可能重复、也可能改名，不适合当主键。C 错：“部门代码”是部门的键，不是项目侧的键。D 错：把“承担任务”当成键的一部分——它是联系的属性，不是标识。

这三空是一条完整的链：先算自然连接的列数（靠同名属性判断），再定联系类型（看基数），最后定联系表主键（双方主键组合）。

选 D。E-R 图转关系模式时，联系的三种处理方式是固定的：

1:1：可以把一方的主键并入另一方，不必单独建表。

1:n（含 n:1）：把“1”端的主键并入“n”端，不必单独建表。

m:n（*:*）：必须转换成独立的关系模式。

原因是多对多联系无法通过“并入一方主键”来表达：无论把哪方的键并到另一方，都会产生重复组，违反 1NF。只能单独建表，用双方主键的组合作为主键。

A、B、C 都是一对一或一对多，都能通过“加外键”解决，不需要独立建表。

这题和真题 60 是同一知识点：60 问“怎么建”，62 问“什么时候必须建”。两题一起记，这个考点就闭环了。

选 A。“确定系统边界”和“关系规范化”分属两个不同阶段，要拆开看：

确定系统边界 → 需求分析。这一阶段要搞清楚“系统做什么、不做什么”，划定范围，产出数据流图、数据字典、需求说明。

关系规范化 → 逻辑设计。这一阶段把概念模型的 E-R 图转换成关系模式，然后用范式理论（1NF→2NF→3NF→BCNF）检查并分解，消除冗余和异常。

B 错：概念设计产出的是 E-R 图，那时还没有“关系模式”，谈不上规范化。C 错：物理设计管的是存储结构、索引、分区，不涉及范式。D 错：顺序也反了，逻辑设计在概念设计之后。

四个阶段串起来记：需求分析（做什么）→ 概念设计（E-R 图）→ 逻辑设计（关系模式 + 规范化）→ 物理设计（存储与索引）。

（51）选 A。逻辑结构设计的任务是把概念模型的 E-R 图转成关系模式，它的输入依据是需求分析阶段的成果。

B 错：概念结构设计是逻辑设计的前一步，产出 E-R 图，但逻辑设计的依据还要追溯到需求。C 错：物理设计在逻辑设计之后。D 错：运行维护是系统上线后的事。

（52）选 C。需求分析阶段的三大产物是：需求说明文档、数据字典、数据流图。

数据字典描述数据项、数据结构、数据流、数据存储；数据流图描述数据的加工与流动；需求说明文档把业务规则和约束写清楚。这三样合起来才是完整的“需求”。

A 错：没有需求说明文档，反而混进了程序文档。B、D 错：程序文档是编码阶段的产物，不可能成为设计依据——那时程序还没写。

这题和真题 63 是一组：63 考“哪个阶段做什么”，64 考“这个阶段的输入是什么”。

选 C。关系规范化针对的是关系模式，而关系模式是在逻辑设计阶段产生的，所以规范化也在这一步做。

完整流程是：需求分析产出数据流图和数据字典 → 概念设计画出 E-R 图 → 逻辑设计把 E-R 图转成关系模式，再用范式理论检查、分解 → 物理设计定存储结构和索引。

A 错：需求分析阶段还没有“表”的概念，只有数据和业务规则。B 错：概念设计用的是 E-R 模型，不是关系模型，谈不上范式。D 错：物理设计关注的是“怎么存”，不是“怎么划分表”。

这题和真题 63 的第二个空完全同源，两年后原样重考。看到“规范化”“范式”“函数依赖”这几个词，直接锁定逻辑设计。

选 C。题干的关键词是“对其他事务都是不可见”——这正是隔离性（Isolation）的定义。

隔离性要解决的问题是：多个事务并发执行时，一个事务的中间状态不能被别的事务看到，否则会出现脏读、不可重复读、幻读。数据库靠锁、MVCC（多版本并发控制）来实现。

A 原子性：事务的操作要么全做、要么全不做，靠 undo 日志回滚。

B 一致性：事务执行前后数据库都处于合法状态，比如转账前后总额不变。它是事务的目的，靠原子性、隔离性、持久性共同保证。

D 持久性：事务一旦提交，结果就永久保存，即使系统崩溃也不丢，靠 redo 日志保证。

四个特性的首字母合起来是 ACID，这是数据库事务的基石。判断时抓关键词：“不可见”是隔离，“不丢”是持久，“全做或全不做”是原子，“状态合法”是一致。

选 D。题干的关键是“即使系统故障，结果仍不丢失”——这是持久性（Durability）。

题目还特意提到“更新可能还在磁盘缓冲区”，这句话是在解释持久性为什么需要额外机制：事务提交时，修改可能还在内存缓冲区里没落盘，如果这时断电，数据就没了。

解决办法是先写日志（redo log）再写数据：提交时先把“我要改什么”写进日志并强制落盘，之后即使崩溃，重启时也能根据日志把没落盘的修改重做一遍。

A 原子性：管“全做或全不做”，靠 undo 日志回滚未提交的事务。

B 一致性：管“状态合法”，是事务的最终目的。

C 隔离性：管“并发事务之间不可见”，靠锁或 MVCC。

一句话记：原子靠 undo，持久靠 redo，隔离靠锁，一致靠前三者共同保证。

选 D。数据库恢复的目标是：系统发生故障后，在尽可能短的时间内把数据库恢复到故障发生前的一致状态，并保证已提交的事务不丢失、未提交的事务被回滚。

A、B、C 都把“恢复”理解成了“重装软件”或“做镜像”，这是把数据库恢复和系统重装混为一谈了。

重装 DBMS 只能让软件可用，数据照样是坏的；做镜像是备份手段，属于预防措施，不是恢复本身——而且镜像只能回到某个时间点，中间已提交的事务会丢。

真正的恢复机制由两部分组成：

日志文件：记录每个事务的开始、修改、提交/回滚，用于 redo（重做已提交）和 undo（回滚未提交）。

备份副本：定期转储数据库，故障后用“最近一次备份 + 之后的日志”重建。

所以恢复 = 备份 + 日志 + 重做/回滚，核心是“把数据带回一致状态”，不是“把软件装回去”。

选 D。数据库恢复靠两样东西配合：备份和日志。

定期备份：把数据库整体复制一份，解决“介质损坏”（磁盘坏了、机房进水）这种灾难。没有备份，日志也救不回来。

日志文件：事务处理时把每次更新写进日志。故障后用它做两件事——redo（重做已提交但没落盘的事务）、undo（回滚未提交的事务）。

两者缺一不可：只有备份，故障点之后的数据全丢；只有日志，磁盘物理损坏时日志本身也没了。

A、B、C 都在说“重装 DBMS 或应用程序”，那是解决软件环境问题，跟数据丢失是两回事——重装一百遍，数据也不会回来。

真题 68 考“恢复是什么”，这道考“恢复靠什么”，两题连起来就是这个知识点的完整答案。

（51）选 C。这考的是 WAL（Write-Ahead Logging，预写日志）原则：对数据的插入、删除、修改，必须先把变更写进日志文件，再改数据文件。

为什么顺序不能反？如果先改数据、后写日志，万一在两步之间崩溃，数据改了但日志没记，恢复时就不知道该撤销还是重做，数据库就处于不一致状态。

（52）选 B。正常运行时，缓冲区（内存）里的数据页不会每改一次就写盘——那样磁盘 I/O 太频繁。数据库按检查点或缓冲区淘汰策略，按时间间隔批量写入数据文件。

A 索引文件、D 数据字典都不是这个流程的落点：索引随数据一起维护，数据字典存的是元数据（表结构、权限），与事务数据无关。

两空合起来就是 WAL 的完整图景：日志先落盘，数据后落盘。真题 67 的“持久性”正是靠这个机制保证的。

这道题的关键是：锁是加在具体数据对象上的，不同数据对象之间的锁互不影响。先画一张表，把每个数据对象上已有的锁列出来：

D1 上有 T1 的共享锁（S）；D2 上有 T2 的排它锁（X）；D3 上有 T3 的排它锁（X）。

锁相容规则只有两条：S 与 S 相容，可以再加 S；X 与任何锁都不相容，别人不能再加任何锁。

（51）选 D。T1 想对 D2、D3 加锁，但 D2、D3 上都有别人的 X 锁，所以不管是加 S 还是加 X，全都失败。

A、B 都错在“都成功”——X 锁之上不可能再成功加任何锁。C 错在“D2 加共享锁成功”——D2 上是 X 锁，加 S 也会被拒。

（52）选 C。T2 想对 D1、D3 加锁：D1 上是 T1 的 S 锁，S 与 S 相容，所以加共享锁成功；D3 上是 T3 的 X 锁，所以加排它锁失败。合起来就是“D1 加共享锁成功，D3 加排它锁失败”。

A 错：D1 上加 S 是成功的。B 错：D3 的 X 锁之上加 S 会失败。D 错：D1 上已有 S 锁，加 X 锁必然失败。

记住这张 2×2 的相容矩阵：S+S 相容，S+X 冲突，X+S 冲突，X+X 冲突。做题时先定位“哪个数据上有什么锁”，再查矩阵。

选 D。这题和真题 71 是同一道题的单空版本，判断方法完全一样。

先把现状列清楚：D1 上是 T1 的共享锁；D2、D3 上分别是 T2、T3 的排它锁。

T1 对 D2、D3 加锁：D2、D3 上都是 X 锁，X 锁排斥一切，所以加 S 失败、加 X 也失败。

T2、T3 对 D1 加锁：D1 上是 S 锁，S 与 S 相容，所以加共享锁成功。

合起来就是“T1 对 D2、D3 加共享锁都失败，T2、T3 对 D1 加共享锁成功”，选 D。

A 错：T1 对 D2、D3 加排它锁不可能成功。B 错：T2、T3 对 D1 加排它锁会失败（S 锁之上不能加 X 锁）。C 错：T1 对 D2、D3 加共享锁也会失败。

这类题最常见的错法是“只看数据不看锁”——以为 D2、D3 是别的数据，T1 应该能加锁。记住：能不能加锁，取决于那个数据上已经有什么锁，和别人的锁在哪个数据上无关。

选 D。分布式数据库有四个“透明”，各自解决一类“不需要知道”：

分片透明：不需要知道数据怎么分块（按什么规则切分、切成了几片）。

位置透明：不需要知道数据存在哪个场地（物理位置）。

复制透明：不需要知道数据有几个副本、副本放在哪。

逻辑透明（局部映像透明）：不需要知道各场地的局部数据模型是什么。

题干说“无需知道数据存放的物理位置”，关键词是“位置”，所以是位置透明。

A 错：分片透明管的是“怎么切”，不是“放在哪”。B 错：复制透明管副本。C 错：逻辑透明管局部模型。

四个透明按粒度从粗到细记：分片（怎么切）→ 位置（放哪）→ 复制（几份）→ 逻辑（什么模型）。

（53）选 D。“局部数据模型透明”指的是：用户不需要知道各个场地用的是什么样的数据模型（这一场地是关系型、那一场地是网状），这是逻辑透明。

（54）选 A。“不需要知道表如何分块存储”，关键词是“分块”，对应分片透明。

B 复制透明管的是副本——有几个副本、副本放在哪些场地，用户不用管。

C 位置透明管的是数据存在哪个场地，与“怎么分块”不是一回事：分片决定“切成几块、按什么规则切”，位置决定“这一块放在哪”。

四者的层次关系可以这样理解：先分片（切成块）→ 再定位置（块放哪）→ 再定副本（要不要备份几份）→ 最后屏蔽局部模型差异（逻辑透明）。层次越高，用户需要知道的越少。

选 C。“不需要知道逻辑上访问的表具体如何分块存储”——关键词“分块”，这就是分片透明。

A 逻辑透明：指不需要知道各场地的局部数据模型。B 位置透明：指不需要知道数据存在哪个场地。D 复制透明：指不需要知道副本的数量和位置。

这题和 2015 下半年（真题 74）的第（54）空是同一句话，只是换了年份、换了选项顺序。2018 下再考一次，说明它是高频送分点。

判断口诀：题干出现“分块／分片／如何划分” → 分片透明；出现“哪个场地／物理位置” → 位置透明；出现“副本／拷贝” → 复制透明；出现“局部模型” → 逻辑透明。

选 C。题干的场景是“某一场地故障，系统还能用其他场地的副本继续服务，不至于瘫痪”——这正是可用性（Availability）。

分布式数据库通过数据冗余（副本）实现高可用：一个场地挂了，请求可以转到存有同一份数据副本的其他场地，业务不中断。

A 共享性：指多个场地可以共享数据资源，是分布式的目的之一，但不描述“故障时仍可用”。

B 自治性：指每个场地能独立管理本地数据、独立处理本地事务，强调的是“各自管好自己”，不是“互相兜底”。

D 分布性：指数据分散存储在多个场地，是物理布局的描述，不涉及故障应对。

分布式数据库的四个特点是：本地自治、非集中管理、位置透明、高可用性。题干描述的就是最后一条。

选 C。这是 2019 上半年原题的重考，一字未改：“某场地故障时使用其他场地副本”，答案是可用性。

为什么不是其他三个：

A 共享性——强调多场地共享数据，不涉及故障。

B 自治性——强调每个场地能独立处理本地事务，是“分工”，不是“兜底”。

D 分布性——强调数据分散存放这个事实，是布局描述。

只有“可用性”直接对应“故障了还能用”。判定方法很简单：题干出现“故障”“瘫痪”“不间断”“继续服务”，就往可用性上想。

顺带记：分布式数据库提高可用性的手段是冗余——同一份数据存多个副本，用空间换可靠性。

选 B。三个实体之间的多对多联系，转成关系模式时主键是三个实体关键字的组合。

理由：一次联系实例必须同时确定“哪个 A、哪个 B、哪个 C”，少了任何一个都无法唯一标识。比如“供应商—项目—零件”的三方联系，要确定“某供应商给某项目供应了某零件”，三个编号都得有。

A 错：只取联系自身的属性（如数量），无法标识是哪三方之间的数量。C 错：只取一个实体的键，另外两方就丢了。D 错：取两个实体的键，第三方仍然无法确定。

这条规则是二元多对多联系的推广：二元 m:n 联系的主键是“双方主键组合”，三元就是“三方主键组合”，n 元就是 n 个主键组合。

选 C。“繁殖（选择）→ 交叉（重组）→ 变异（突变）”这三步是遗传算法（Genetic Algorithm）的标准流程。

遗传算法借用了生物进化的概念：

选择：按适应度挑出较优的个体，让它们有更多机会繁殖（优胜劣汰）。

交叉：两个父代交换部分基因，产生新个体（组合优良性状）。

变异：以很小的概率随机改变某个基因，保持种群多样性，避免早熟收敛。

A 粒子群（PSO）：靠“速度 + 位置”更新，向个体最优和全局最优靠拢，没有交叉变异。

B 人工神经网络：靠反向传播调整权重，是梯度下降的思路。

D 蚁群算法：靠信息素的正反馈寻找路径。

四种智能算法的标志性机制要分清：遗传看“交叉变异”，粒子群看“速度位置”，蚁群看“信息素”，神经网络看“权值更新”。

选 C。这道题考的是多值属性与 4NF 的关系。

多值属性：一个实体在该属性上有多个取值，比如一个员工有多个电话号码、一门课有多个先修课。

把含多值属性的实体转成关系模式，正确做法是：实体的码 + 每一个多值属性，各自独立构成一个关系模式。

比如员工（员工号, 姓名）有“电话”和“技能”两个多值属性，就拆成员工电话（员工号, 电话）、员工技能（员工号, 技能），而不是把两个多值属性放在同一张表里。

为什么不能放一起？如果放在同一张表（员工号, 电话, 技能），“3 个电话 × 4 个技能”会组合出 12 行，产生大量冗余——这就是多值依赖。4NF 的要求正是“消除非平凡的多值依赖”。

A 错：把所有多值属性塞进一张表，多值依赖依然存在。B 错：让多值属性消失，信息就丢了。D 错：把多值属性和普通属性混在一起，正是违反 4NF 的做法。

选 A。JDBC（Java Database Connectivity）是 Java 访问关系数据库的标准 API，通过它可以用统一的接口连接 MySQL、Oracle、SQL Server 等不同数据库，执行 SQL 并处理结果集。

题干说“基于 Web 的电子商务应用”，这类系统通常是 Java 技术栈（JSP／Servlet／Spring），后端访问数据库的常用方式正是 JDBC。

B 错：XML 是一种数据格式，用来传输和存储结构化数据，本身不能访问数据库。

C 错：CGI 是早期的 Web 服务器与外部程序之间的网关接口，不是数据库访问接口。

D 错：COM 是微软的组件对象模型，用于组件之间的调用，不是数据库访问的标准方式（微软对应的数据库接口是 ADO／OLEDB）。

这类题的关键是把“层级”分清：JDBC 是数据访问层的接口，XML 是数据表示，CGI 是Web 网关，COM 是组件模型。

选 B。Armstrong 公理系统有三条基本公理和三条推论，本题考的是推论中的“伪传递”。

三条基本公理：

自反律：若 Y ⊆ X，则 X→Y。

增广律：若 X→Y，则 XZ→YZ（选项 D）。

传递律：若 X→Y、Y→Z，则 X→Z（选项 C）。

三条推论：

合并规则：若 X→Y、X→Z，则 X→YZ（选项 A）。

分解规则：若 X→YZ，则 X→Y、X→Z。

伪传递规则：若 X→Y、WY→Z，则 XW→Z（选项 B）。

伪传递的形状要认准：第一条的右边 Y 出现在第二条的左边（作为 WY 的一部分），结论是把 X 和 W 拼起来决定 Z。它比普通传递多了一个 W，所以叫“伪”。

（54）选 A。SQL 创建函数的语法是：

CREATE FUNCTION 函数名(参数列表)
RETURNS 返回类型
BEGIN
  ...
END

所以第一个空是 RETURNS INTEGER——声明这个函数返回一个整数（教师人数）。

B 错：RETURNS d_count INTEGER 把变量名写进了返回类型，语法不成立。C、D 用了 DECLARE，那是声明局部变量的关键字，不能放在参数列表后面声明返回类型。

（55）选 D。函数体里要先声明一个变量来接收 COUNT 的结果：DECLARE d_count INTEGER。

后面那句 SELECT count(*) INTO d_count 就是把查询结果赋给这个变量。如果不先 DECLARE，d_count 就是未定义的。

顺序很重要：先 RETURNS 定返回值类型，再 DECLARE 定局部变量。两处都用 INTEGER，但作用完全不同——一个是“函数交出去的东西”，一个是“函数内部用的临时格子”。

选 B。题干的关键词是“从时间、地区、商品种类三个维度分析销售数据”，这是典型的多维分析，对应 OLAP（联机分析处理）。

OLAP 的核心操作就是围绕“维度”和“度量”做文章：

切片：固定一个维度取值，看剩下维度的数据。

切块：固定多个维度区间。

钻取：从汇总数据下钻到明细（比如从“年度”下钻到“月度”）。

旋转：换维度组合看同一个立方体。

C 错：OLTP（联机事务处理）是日常业务系统，特点是短事务、高频增删改查，不做多维分析。

D 错：ETL 是“抽取—转换—加载”，负责把源数据搬进数据仓库，是分析之前的准备工序。

A 错：Data Extraction 只是 ETL 的第一步，更不完整。

一句话区分：OLTP 管“记账”，ETL 管“搬数据”，OLAP 管“看趋势”。

选 B。存储过程把一组 SQL 语句预编译后存在数据库服务器端，第三方开发人员只能“调用过程名 + 传参数”，看不到里面查了哪些表、表结构是什么。

这正好满足题干的两个要求：① 提供接口供第三方做数据更新；② 保证关系模式不被获取。

A 错：触发器是由事件（INSERT／UPDATE／DELETE）自动触发的，不是给第三方主动调用的接口。

C 错：视图确实能隐藏部分表结构，但它只解决“看什么”，不封装“怎么改”。通过视图更新还受很多限制（含聚合、多表连接的视图通常不可更新），无法承担业务逻辑。

D 错：索引是加速查询的物理结构，与权限隔离、接口封装无关。

存储过程的价值可以归为三点：封装业务逻辑、减少网络传输、作为权限边界。本题考的是第三点——只给 EXECUTE 权限、不给表权限，第三方就碰不到底层模式。