标签：候选 闭包 依赖 包含 数据库 最小 课程 冗余 属性

目录

• 数据依赖的公理系统
  • Armstrong 公理
  • 函数依赖闭包
• 最小函数依赖集
  • 最小函数依赖集的定义
  • 最小依赖集的计算算法
  • 样例
    • 样例一
    • 样例二
    • 样例三
• 求候选键
  • 候选键的求法
  • 样例
    • 样例一
    • 样例二
    • 样例三
• 参考资料

数据依赖的公理系统

Armstrong 公理

设有关系模式 R(U) 及其函数依赖集 F，如果对于 R 的任一个满足 F 的关系 r 函数依赖 X→Y 都成立，则称 F 逻辑蕴涵 X→Y，或称 X→Y 可以由 F 推出。给定关系模式 R(U) 和 FD 集 F，Armstrong 公理规定了以下的推理规则：

推理规则	说明
A1 自反律	若 Y⊆X⊆U, 则 X⊆Y 成立(平凡依赖)
A2 增广律	若 Z⊆U 且 X→Y，则 XZ→YZ 成立
A3 传递律	若 X→Y，Y→Z，则 X→Z 成立

根据以上三条公理，可得到以下推理规则：

推理规则	说明
合并规则	若 X→Y，X→Z，则 X→YZ 成立
伪传递规则	若 X→Y，WY→Z，则 WX→Z 成立
分解规则	若 X→Y，且 Z⊆Y，则 X→Z 成立
复合规则	若 X→Y，且 W→Z，则 XW→ZY 成立

函数依赖闭包

在关系模式 R<U，F> 中为 F 所逻辑蕴含的函数依赖的全体叫作 F 的闭包，记为 F+。设 F 为属性集 U 上的一组函数依赖，X⊆U，XF+={A|X→A 能由 F 根据 Armstrong 公理导出}，XF+ 称为属性集 X 关于函数依赖集 F 的闭包。
翻译成人话就是你有一些字母 X，通过函数依赖集 F 的箭头可以得到的所有字母就是 X 关于 F 的闭包。例如设属性集 U={A,B,C}，函数依赖集 F={A→B, B→C} 则 AF+={A，B，C}，BF+={B，C}，CF+={C}。

最小函数依赖集

最小函数依赖集的定义

最小函数依赖集是函数依赖集 F 如果满足下列条件，则称 F 为最小函数依赖集：

1. F 中每一个函数依赖的右部都是单个属性；
2. 对 F 中任一函数依赖 X→A，F-{X→A｝都不与 F 等价；
3. 对于 F 中的任一函数依赖 X→A，X 有真子集 Z 使得｛X→A}∪{Z→A｝都不与 F 等价。

翻译成人话就是你有一些你有一些字母 X 和函数依赖集 F，你可以找到一个更小的函数依赖集，它的所有函数依赖的箭头右边都只有一个字母，且不影响把箭头右边的字母都推出来。

最小依赖集的计算算法

1. 应用分解规则，使 F 中每一个依赖的右部属性单一化。
2. 去掉各依赖左部多余的属性。具体做法是：一个一个地检查 F 中左边是非单属性的依赖，例如 XY→A。判断Y是否为多余的，即以 X→A 代替 XY→A 是否等价，在 F 中求 X+，若 X+ 包含
   A，则 Y 是多余的属性；否则 Y 不是多余属性。依次判断其他属性即可消除各依赖左边的多余属性。
3. 去掉多余的依赖。具体做法是：从第一个依赖开始，从 F 中去掉它(假设该依赖为 X→Y)，然后在剩下的依赖中求 X，看 X+ 是否包含 Y，若是则去掉 X→Y，若不包含 Y 则不能去掉 X→Y。

样例

样例一

先看一个简单的例，属性集 ABC 上的 FD 集，设 F={A→BC, B→AC, C→A}，求 Fm。第一步先将每一个依赖的右部属性单一化：

F={A→B, A→C, B→A, B→C, C→A}

接着去掉各依赖左部多余的属性：

判断 A→B 是否冗余：G1={A→C, B→A, B→C, C→A}
    AG1+=AC，B 不属于 AG1+，A→B 不冗余；

判断 A→C 是否冗余：G2={A→B, B→A, B→C, C→A}
    AG2＋= ABC，C∈AG2＋，A→C 冗余，
    修改为：F={A→B, B→A, B→C,C→A}；    

判断 B→A 是否冗余：G3={A→B, B→C, C→A}
    BG3＋= ABC，A∈BG3＋，B→A 冗余，
    F={A→B, B→C, C→A}；

判断 B→C 是否冗余：G4={A→B, C→A}
    BG4＋=B，C 不属于 BG4＋，B→C 不冗余；

判断 C→A 是否冗余：G5={A→B, B→C}
    CG5＋=C，A 不属于 CG5＋，C→A 不冗余。  

由于例中函数依赖的决定因素均为单属性，因而不需要第三步检查，上述结果就是最小函数依赖集。

Fm＝{A→B, B→C, C→A}

样例二

接着看一个啰嗦点的例子，设有依赖集 F，计算与其等价的最小依赖集。

F＝{MN→XZ, M→X, GP→N, ZP→M, XYZ→P, HN→P, Y→H, MNX→PG}

第一步，右边单一化：

F1＝{MN→X, MN→Z, M→X, GP→N, ZP→M, XYZ→P, HN→P, Y→H, MNX→P, MNX→G}

第二步：逐个求，在去掉它的 F 中求闭包

去掉 MN→X  后，求得的闭包包含   X，不保留
去掉 MN→Z  后，求得的闭包不包含 Z，保留
去掉 M→X   后，求得的闭包不包含 X，保留
去掉 GP→N  后，求得的闭包不包含 N，保留
去掉 ZP→M  后，求得的闭包不包含 M，保留
去掉 XYZ→P 后，求得的闭包不包含 P，保留
去掉 HN→P  后，求得的闭包不包含 P，保留
去掉 Y→H   后，求得的闭包不包含 H，保留
去掉 MNX→P 后，求得的闭包不包含 P，保留
去掉 MNX→G 后，求得的闭包不包含 G，保留

去掉各依赖左部多余的属性后得到：

F2＝{MN→Z, M→X, GP→N, ZP→M, XYZ→P, HN→P, Y→H, MNX→P, MNX→G}

第三步，对左边属性单一化：

MN→Z：
    M→Z，求(M)+不包含 Z，所以 N 不冗余。
    N→Z，求(N)+不包含 Z，所以 M 不冗余。

GP→N：
    G→N，求(G)+不包含 N，所以 P 不冗余。
    P→N，求(P)+不包含 N，所以 G 不冗余。

ZP→M：
    Z→M，求(Z)+不包含 M，所以 P 不冗余。
    P→M，求(P)+不包含 M，所以 Z 不冗余。

XYZ→P：
    XY→P，求(XY)+不包含 P，所以 Z 不冗余。
    YZ→P，求(YZ)+不包含 P，所以 X 不冗余。
    XZ→P，求(XZ)+不包含 P，所以 Y 不冗余。

HN→P：
    H→P，求(H)+不包含 P，所以 N 不冗余。
    N→P，求(N)+不包含 P，所以 H 不冗余。

MNX→P：
    MN→P，求(MN)+包含   P，所以 X 冗余。
    MX→P，求(MX)+不包含 P，所以 N 不冗余。
    NX→P，求(NX)+不包含 P，所以 M 不冗余。

MNX→G：
    MN→G，求(MN)+包含   G，所以 X 冗余。
    MX→G，求(MX)+不包含 G，所以 N 不冗余。
    NX→G，求(NX)+不包含 G，所以 M 不冗余。

综上所述，去掉多余的依赖后得到最小函数依赖集。

Fm＝{MN→Z, M→X, GP→N, ZP→M, XYZ→P, HN→P, Y→H, MN→P, MN→G}

样例三

最后给一个实际的例子，设有关系模式如下。设一个学生可以选多门课程，一门课程可以被多名学生选。一个学生有唯一的所在系，每门课程有唯一的课程名和学分。每个学生对每门课程有唯一的成绩。

学生修课(学号, 姓名, 所在系, 性别, 课程号, 课程名, 学分, 成绩）

对关系模式归纳出函数依赖如下，得到候选键是{学号，课程号}。

学号→(姓名, 所在系, 性别)
课程号→(课程名, 学分)
(学号, 课程号)→成绩

第一步，右边单一化：

F1={学号→姓名, 学号→所在系, 学号→性别, 课程号→课程名, 课程号→学分, (学号, 课程号)→成绩}

第二步逐个求，在去掉它的F中求闭包。

去掉“学号→姓名”后，求得的闭包不包含“姓名”，保留
去掉“学号→所在系”后，求得的闭包不包含“所在系”，保留
去掉“学号→性别”后，求得的闭包不包含“性别”，保留
去掉“课程号→课程名”后，求得的闭包不包含“课程名”，保留
去掉“课程号→学分”后，求得的闭包不包含“学分”，保留
去掉“(学号, 课程号)→成绩”后，求得的闭包不包含“课程号”，保留

去掉各依赖左部多余的属性后得到：

F2={学号→姓名, 学号→所在系, 学号→性别, 课程号→课程名, 课程号→学分, (学号, 课程号)→成绩}

第三步，对左边属性单一化：

(学号，课程号)→成绩：
    学号→成绩，求(学号)+不包含“成绩”，所以“学号”不冗余。
    课程号→成绩，求(课程号)+不包含“成绩”，所以“课程号”不冗余。

综上所述，去掉多余的依赖后得到最小函数依赖集。

Fm={学号→姓名, 学号→所在系, 学号→性别, 课程号→课程名, 课程号→学分, (学号，课程号)→成绩}

求候选键

候选键的求法

博客数据库原理：数据模型和关系数据库有提到过，候选码是它的值能唯一地标识一个元组，而其子集不能标识的属性组。
由于其他求法我都没看懂，所以只介绍快速判断方法。先计算函数依赖集 F 的最小函数依赖集，然后采用快速判定法，以及候选键的定义来确定候选键。对于给定的关系 R(U, F)，可将其属性分为四类：

属性类别	说明
L 类	仅出现在函数依赖集 F 的左部的属性
R 类	仅出现在函数依赖集 F 的右部的属性
LR 类	在函数依赖集 F 的左右两边均出现的属性
N 类	在函数依赖集 F 的左右两边均未出现的属性

快速求解候选码的一个充分条件是，对于给定的关系模式 R(U, F)，X∈U：

1. 若 X 是 R 的 L 类属性，则 X 必为 R 的任一候选码中的属性；
2. 若 X 是 R 的 R 类属性，则 X 必不在 R 的任一候选码中；
3. 若 X 是 R 的 N 类属性，则 X 必为 R 的任一候选码中的属性。

快速求解候选码过程：

1. 将 R 的所有属性分为 L、R、N 和 LR 四类，并令 X 代表 L、N 两类，Y 代表 LR 类；
2. 求属性集闭包 X+，若 X+ 包含了 R 的全部属性则 X 即为 R 的唯一候选码，转(5)；
3. 在 Y 中取一属性 A，求属性集闭包(XA)+，若(XA)+包含了 R 的全部属性，则转(4)；否则调换一属性反复进行这一过程，直到试完所有 Y 中的属性；
4. 如果已找出了所有的候选码，则转(5)；否则在 Y 中依次取 2个、3个、…… 属性，求 X 与它们的属性集闭包，直到其闭包包含 R 的全部属性；
5. 停止，输出结果。

样例

样例一

设有关系模式 R(M, N, X, Y)，其函数依赖集 F={Y→N, N→Y, MY→N, MX→Y}，求 R 的所有候选键。

Left：{M, X}
LR：{N, Y}
Not：{}
因为对 {Left，Not}F+=R，所以{M，X}是 R 的所有候选键。

样例二

设有关系模式 R(U, F)，其中 U={M, N, X, Y, Z, P}，F={M→N, X→Y, Z→ M ,XZ→Y}，试求此关系的候选键。

Left：{X，Z}
LR：{M}
Not：{P}
因为对{Left，Not}F+=R，所以{X, Z, P}是 R 的所有候选键

样例三

设关系模式 R(S, D, I, B, O, Q)，其函数依赖集 F={S→D, I→B, B→O, O→Q, Q→I}，求 R 的所有候选码。

Left：{S}
LR：{I, B, O, Q}
Not：{}

因为S+=SD，所以 S 不是 R 的候选码；
因为(SI)+=SIDBOQ，所以 SI 是一个候选码；
因为(SB)+=SBDOQI，所以 SB 是一个候选码；
因为(SO)+=SODQIB，所以 SO 是一个候选码； 
因为(SQ)+=SQDIBO，所以 SQ 是一个候选码。

参考资料

《数据库系统概论(第5版)》，王珊 萨师煊 编著，高等教育出版社

标签：候选,闭包,依赖,包含,数据库,最小,课程,冗余,属性
来源： https://www.cnblogs.com/linfangnan/p/16683327.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。