企业官网建设流程全解析

简介：这份资源是钱学忠《数据库原理及技术》教材的习题答案与配套资料，面向高校计算机专业学生、备考数据库相关课程的学习者，以及希望巩固数据库设计与管理能力的从业者。内容围绕数据库设计、SQL语言、关系数据库理论、DBMS与数据库管理等核心章节展开，可帮助读者对照教材检验理解、解决课后习题中的实际问题。资源以rar压缩包形式提供，整体约16.69MB，上游未提供具体文件数量与类型明细，下载后可按章节模块检索使用。目前已有693人学习下载，适合在课程复习、实验报告撰写与知识点查漏补缺时参考。通过答案与教材内容的对照，读者能进一步梳理E-R模型转换、关系代数运算、范式规范化、事务控制与备份恢复等关键思路，提升数据库设计与管理的综合能力。

1. 从一份课后答案说起：数据库原理到底该怎么学

如果你正在搜“数据库原理及技术 钱学忠 答案”，大概率不是想抄答案交差，而是被关系代数、范式分解、事务调度这几块卡住了，想找个参照物对一下自己的推导过程。我当年带新人时也遇到过同样的情况：教材上的例题看懂了，一到课后习题就不知道从哪下手，尤其是 SQL 写出来能跑，但问“为什么这么写”“换个写法行不行”就答不上来。这份答案资源的价值不在于给你一个抄的模板，而在于它把教材里那些跳步的推导过程补全了，让你能看到每一步的依据。它适合正在跟这本教材上课的在校生、准备数据库相关考试的人，以及想回头把关系模型和事务理论重新捋一遍的开发者。下面我按自己拆解这类资源的习惯，把怎么用、怎么验证、哪里容易翻车讲清楚。

2. 关系代数与 SQL 的对应关系：答案里的推导逻辑怎么读

2.1 先分清答案里哪些是“形式推导”，哪些是“工程写法”

翻这份答案的时候，第一件事是区分两类内容。一类是关系代数表达式、范式判定、函数依赖闭包计算，这些是纯形式推导，答案给的是标准步骤，你照着走一遍能验证自己哪里漏了。另一类是 SQL 建表、查询、视图、存储过程，这些有工程上的写法差异，答案给的是一种可行解，不一定是最优解。我一般建议先做形式推导部分，因为那部分对错分明，做完再去看 SQL 部分，心里有底。

举个典型例子，教材里讲自然连接和等值连接的区别，答案可能直接给出结果关系，但没写清楚为什么某些元组被消掉了。这时候你要回到定义：自然连接是在笛卡尔积基础上，对同名属性取等值，然后去掉重复列。把这个过程手动展开一遍，比看十遍答案都管用。

2.2 用一段 SQL 反推关系代数，验证自己是否真懂了

答案里经常出现“写出下列查询的关系代数表达式和 SQL 语句”这类题。我的做法是先自己写 SQL，再把 SQL 翻译成关系代数，最后跟答案对。翻译规则不复杂：FROM 对应笛卡尔积或连接，WHERE 对应选择，SELECT 对应投影，GROUP BY 对应分组聚合。下面这段代码演示一个典型的“查询选修了某门课的学生姓名”的写法，你可以拿它跟答案里的关系代数对照。

-- 查询选修了“数据库原理”这门课的学生姓名 -- 对应关系代数：π Sname (σ Cname='数据库原理' (Student ⋈ SC ⋈ Course)) SELECT DISTINCT s.Sname FROM Student s JOIN SC sc ON s.Sno = sc.Sno JOIN Course c ON sc.Cno = c.Cno WHERE c.Cname = '数据库原理';

这段 SQL 里，JOIN 对应自然连接，WHERE 对应选择，SELECT DISTINCT 对应投影并去重。如果你写的 SQL 跟答案的关系代数对不上，问题通常出在两个地方：一是连接顺序搞错了，导致中间结果集不对；二是忘了去重，关系代数里投影默认去重，但 SQL 的 SELECT 不去重，必须加 DISTINCT。这两个坑我在批改作业时见过太多次。

2.3 函数依赖闭包计算：答案跳步最多的地方

函数依赖闭包和候选码求解是答案里跳步最严重的地方。教材上通常只给最终结果，比如“候选码为 (Sno, Cno)”，但怎么推出来的没写。我一般会要求按属性闭包算法一步步来：从给定的函数依赖集出发，对每个属性组合求闭包，看哪个闭包包含全部属性。下面用 Python 写一个最小实现，你可以拿它验证答案里的候选码。

# 属性闭包计算：给定函数依赖集 F 和属性集 X，求 X 的闭包 def closure(X, F): result = set(X) changed = True while changed: changed = False for lhs, rhs in F: if set(lhs).issubset(result) and not set(rhs).issubset(result): result |= set(rhs) changed = True return result # 示例：R(A,B,C,D)，F = {A->B, B->C, A->D} F = [('A', 'B'), ('B', 'C'), ('A', 'D')] print(closure('A', F)) # 输出 {'A','B','C','D'}，说明 A 是候选码

这段代码的逻辑是：从 X 开始，反复扫描函数依赖集，只要某个依赖的左部已经在结果集里，就把右部并进来，直到不再变化。参数 F 是函数依赖列表，每个元素是 (左部, 右部) 的元组。跑一遍就能看出答案里的候选码是怎么来的。如果答案给的候选码跟你的计算结果不一致，先检查函数依赖集有没有抄错，再检查闭包算法有没有漏掉传递依赖。

3. 范式判定与分解：答案里的“标准解”和你的解可能都对

3.1 范式判定的顺序不能乱

答案里做范式判定时，通常按 1NF → 2NF → 3NF → BCNF 的顺序逐级检查。这个顺序不能跳，因为高级范式的前提是已经满足低级范式。我见过有人直接判 BCNF，结果连 1NF 都没满足，整个推导就废了。具体操作是：先看每个属性是不是原子的，再看非主属性是否完全依赖于候选码，再看有没有传递依赖，最后看每个决定因素是否包含候选码。

答案里经常出现“该关系模式属于 3NF 但不属于 BCNF”这种结论。你要能说出为什么：3NF 允许主属性对候选码的传递依赖，BCNF 不允许。如果答案只给结论没给理由，你就自己补一个反例，把那个传递依赖写出来。

3.2 模式分解：无损连接和保持依赖的取舍

模式分解是答案里最容易出现“多种正确解”的地方。同一个关系模式，可以分解成不同的子模式集，只要满足无损连接和保持依赖就行。答案给的是一种分解方案，你给的可能是另一种，两个都对。这时候不要慌，用两个标准去验证：一是无损连接，用 Chase 算法或者表格法检查；二是保持依赖，看原来的函数依赖是不是都能在某个子模式上推导出来。

下面用表格列出常见的分解判定方法，方便你对照答案检查。

我一般会先用合成法做 3NF 分解，因为步骤固定，不容易出错。BCNF 分解则要反复迭代，直到所有决定因素都包含候选码。答案如果只给最终分解结果，你就自己把中间步骤补上，这样才能真正掌握。

3.3 用代码验证分解是否无损

无损连接的 Chase 算法可以手算，但属性多了容易乱。我写过一个简化版，用来验证答案里的分解方案。

# 无损连接判定：简化版 Chase 算法 # 输入：属性列表 attrs，分解后的子模式列表 decomp，函数依赖集 F def is_lossless(attrs, decomp, F): # 初始化表格：每行对应一个子模式，每列对应一个属性 table = [] for i, sub in enumerate(decomp): row = {} for a in attrs: row[a] = f'a{i}' if a in sub else None table.append(row) # 反复扫描函数依赖，尝试统一符号 changed = True while changed: changed = False for lhs, rhs in F: # 找到左部在所有行上取值相同的行 groups = {} for i, row in enumerate(table): key = tuple(row[a] for a in lhs) groups.setdefault(key, []).append(i) for key, rows in groups.items(): if len(rows) > 1: for a in rhs: vals = [table[i][a] for i in rows] if len(set(vals)) > 1: # 统一为第一个非空值 target = next(v for v in vals if v is not None) for i in rows: if table[i][a] != target: table[i][a] = target changed = True # 检查是否存在一行全为 a 符号（简化判断：某行所有属性都有值） for row in table: if all(row[a] is not None for a in attrs): return True return False attrs = ['A', 'B', 'C', 'D'] decomp = [['A', 'B'], ['B', 'C'], ['C', 'D']] F = [('A', 'B'), ('B', 'C'), ('C', 'D')] print(is_lossless(attrs, decomp, F)) # 输出 True

这段代码的核心是模拟 Chase 算法的符号统一过程。参数 attrs 是全部属性，decomp 是分解后的子模式列表，F 是函数依赖集。如果最终某一行所有属性都有确定值，说明分解是无损的。你可以拿它去验证答案里的分解方案，如果输出 False，要么是答案错了，要么是你抄错了依赖集。

4. 事务与并发控制：答案里最容易踩坑的章节

4.1 可串行化调度的判定：优先图怎么画

事务并发这一块，答案里经常给出一组调度，让你判断是否可串行化。标准做法是画优先图：如果两个事务存在冲突操作（读写同一数据项且至少一个是写），就根据操作顺序画一条有向边。最后看图中是否有环，有环就不可串行化。

我见过很多人直接凭感觉判断，结果遇到“两个事务交叉读写”就翻车。正确做法是老老实实列出所有冲突操作对，逐个画边。答案如果只给“可串行化”或“不可串行化”的结论，你就自己把优先图画出来，跟答案对一下边的方向。

4.2 两段锁协议和死锁：答案里的调度序列怎么读

两段锁协议要求每个事务分两个阶段：加锁阶段只能加锁不能解锁，解锁阶段只能解锁不能加锁。答案里给出的调度序列，你要检查每个事务是否满足这个约束。常见错误是把解锁放在加锁之前，或者中间又加了一个锁。

死锁检测也是常考点。答案可能给一个等待图，让你判断有没有死锁。等待图里有环就是死锁。我一般会建议先画资源分配图，再转成等待图，这样不容易漏边。

4.3 用代码模拟一个并发调度

下面这段 Python 代码模拟两个事务的并发执行，并检查是否满足两段锁协议。

# 模拟两段锁协议检查 # 输入：调度列表，每个元素是 (事务名, 操作, 数据项) # 操作：'lock' 加锁，'unlock' 解锁，'read' 读，'write' 写 def check_2pl(schedule): locked = {} # 记录每个事务当前持有的锁 unlocked = {} # 记录每个事务是否已经进入解锁阶段 for txn, op, item in schedule: if op == 'lock': if unlocked.get(txn, False): return f'事务 {txn} 在解锁后又加锁，违反两段锁协议' locked.setdefault(txn, set()).add(item) elif op == 'unlock': unlocked[txn] = True locked.get(txn, set()).discard(item) elif op in ('read', 'write'): if item not in locked.get(txn, set()): return f'事务 {txn} 在未加锁的情况下操作 {item}' return '满足两段锁协议' schedule = [ ('T1', 'lock', 'A'), ('T1', 'read', 'A'), ('T2', 'lock', 'B'), ('T2', 'write', 'B'), ('T1', 'unlock', 'A'), ('T2', 'unlock', 'B'), ] print(check_2pl(schedule))

这段代码的逻辑是：维护每个事务的锁集合和解锁标记，一旦某个事务在解锁后又加锁，就报违规。参数 schedule 是调度序列，每个元素包含事务名、操作类型和数据项。你可以拿它去检查答案里的调度序列，看看自己判断得对不对。

5. 避坑与排查：对答案时最容易翻车的五个地方

5.1 现象：SQL 能跑但结果跟答案不一样

原因：最常见的是 NULL 值处理。SQL 里 NULL 参与比较返回 UNKNOWN，而关系代数里没有 NULL 的概念。答案如果基于纯关系模型，你的 SQL 可能因为 NULL 导致结果集不同。解决：在 WHERE 里显式处理 NULL，比如用 IS NULL 或 COALESCE，或者先确认题目里的数据是否允许 NULL。

5.2 现象：范式判定结果跟答案差一级

原因：候选码求错了。候选码错了，后面的完全依赖、传递依赖判断全跟着错。解决：回到函数依赖集，用属性闭包算法重新求候选码，确保每个候选码的闭包都包含全部属性，且没有冗余属性。

5.3 现象：模式分解后自然连接出现多余元组

原因：分解不是无损的，或者 Chase 算法里符号统一没做彻底。解决：用第 3 章给的代码重新跑一遍无损连接判定，如果输出 False，检查分解方案是否漏了某个函数依赖的右部属性。

5.4 现象：并发调度判断为可串行化但答案说不可

原因：优先图漏边了。冲突操作不仅包括读写同一数据项，还包括写写同一数据项。解决：把所有事务的操作按时间顺序列出来，逐对检查是否有冲突，别凭感觉跳步。

5.5 现象：答案里的关系代数表达式看不懂

原因：答案用了教材特有的符号简写，比如用除号表示“包含全部”的查询。解决：把除号展开成基本运算：R ÷ S 等价于 π(R) - π((π(R) × S) - R)。展开后再跟自己的写法对，通常就能看懂了。

6. 把答案用成学习工具：我的三个固定动作

第一个动作是“先做后对”。不管多简单的题，先自己在纸上写一遍，再翻答案。直接看答案会产生“我会了”的错觉，实际动手时才发现卡壳。我一般会准备两张纸，一张写自己的推导，一张写答案的推导，逐行对比，差异处用红笔标出来。

第二个动作是“给答案挑错”。这份答案不是官方出版物，难免有笔误或跳步。遇到觉得不对劲的地方，先别怀疑自己，用第 2 章和第 3 章的代码验证一遍。如果代码结果跟答案不一致，大概率是答案错了。我遇到过好几次答案里候选码写错的情况，验证之后反而加深了理解。

第三个动作是“把答案改写成自己的话”。每道题的推导过程，用自己的语言重新写一遍，尤其是范式分解和并发调度这种步骤多的题。写完之后，隔一天再拿出来看，如果能顺畅复述，说明真懂了；如果卡住，就回到对应章节重新过。

下面这张表是我整理的对答案检查清单，每次做完题花两分钟过一遍，能省下大量返工时间。

从那以后我每次对答案都强制走一遍这个清单，尤其是函数依赖和模式分解这两块，宁可多花十分钟验证，也不愿意事后返工。希望这些经验帮到你，少走一些我当年踩过的弯路。

本文还有配套的精品资源，点击获取