数据库规范化理论大题考点
文章目录
1.Closure of Attributes 属性集的闭包相关题型
1.1 属性集闭包的算法
result:= α;
repeat
for each 函数依赖β→r in F do
begin
if β 蕴涵于 result then result := result ∪ r;
end
until (result 不变)
对函数依赖集F下的每一个函数依赖，如果依赖的左边 β \beta β在结果属性集中，那么依赖的右边 γ \gamma γ加入到结果集中。重复直至result不变
- 例1：计算属性闭包
$Example :Given\ R<U,F>, R = {A,B,C,D},F={B\rightarrow CD,AD\rightarrow E,B\rightarrow A}\$
( B C ) + ? (BC)^+? (BC)+?
解：
1.
R
e
s
u
l
t
=
{
B
C
}
2.
R
e
s
u
l
t
=
{
A
B
C
D
}
3.
R
e
s
u
l
t
=
{
A
B
C
D
E
}
1.Result = \{BC\}\\ 2.Result = \{ABCD\}\\ 3.Result = \{ABCDE\}
1.Result={BC}2.Result={ABCD}3.Result={ABCDE}
- 例2：判断函数依赖是否成立
定理： X → Y ⇔ Y ⊆ ( X F ) + X\rightarrow Y\Leftrightarrow Y\subseteq (X_F)^+ X→Y⇔Y⊆(XF)+
( A B ) F + = { A , B , C , D , E } (AB)_F^+ = \{A,B,C,D,E\} (AB)F+={A,B,C,D,E}， A B → E AB\rightarrow E AB→E成立
1.2 最小依赖的计算
算法：
- 函数依赖的右部分解成单属性的函数依赖
- 去掉函数依赖的左部的冗余属性
- 去掉冗余的函数依赖
例子
-
例1
- 分解
F = { A → B , A → C , B → C , A B → C } F = \{A\rightarrow B,A\rightarrow C,B\rightarrow C,AB\rightarrow C\} F={A→B,A→C,B→C,AB→C}
-
去掉左部冗余属性
考察 A B → C AB\rightarrow C AB→C中B是否冗余。即考虑函数依赖集F是否逻辑蕴含函数依赖集 F 1 = { A → B , A → C , B → C , A → C } F_1 = \{A\rightarrow B,A\rightarrow C,B\rightarrow C,A\rightarrow C\} F1={A→B,A→C,B→C,A→C}
计算 A F + = { B C } ⊇ C A_F^+ = \{BC\}\supe {C} AF+={BC}⊇C，所以B冗余，去除
得到 F 1 = { A → B , A → C , B → C } F_1 = \{A\rightarrow B,A\rightarrow C,B\rightarrow C\} F1={A→B,A→C,B→C}
-
去除冗余的函数依赖
计算属性闭包 A F 1 − ( A → C ) + = A B C ⊇ C A^+_{F_1-(A\rightarrow C)} = {ABC}\supe {C} AF1−(A→C)+=ABC⊇C，所以函数依赖 A → C A\rightarrow C A→C多余，得到 F 2 = { A → B , B → C } F_2 = \{A\rightarrow B,B\rightarrow C\} F2={A→B,B→C}
1.3 正则覆盖的计算
正则覆盖可以由最小覆盖合并得到。
step1：分解右部
F
=
{
A
→
B
,
A
→
C
,
B
C
D
→
E
,
B
→
D
,
A
→
D
,
E
→
A
}
F = \{A\rightarrow B,A\rightarrow C,BCD\rightarrow E,B\rightarrow D,A\rightarrow D,E\rightarrow A\}
F={A→B,A→C,BCD→E,B→D,A→D,E→A}
step2：去除左部的冗余属性
- 考察 B C D → E BCD\rightarrow E BCD→E中B是否冗余，即考察函数依赖集F是否逻辑蕴含函数依赖集 F 1 = { A → B , A → C , C D → E , B → D , A → D , E → A } F_1 = \{A\rightarrow B,A\rightarrow C,CD\rightarrow E,B\rightarrow D,A\rightarrow D,E\rightarrow A\} F1={A→B,A→C,CD→E,B→D,A→D,E→A}，计算 ( C D ) F + = { } (CD)_F^+ = \{\} (CD)F+={}，所以B不冗余。
- 考察 B C D → E BCD\rightarrow E BCD→E中C是否冗余，即考察函数依赖集F是否逻辑蕴含函数依赖集 F 2 = { A → B , A → C , B D → E , B → D , A → D , E → A } F_2 = \{A\rightarrow B,A\rightarrow C,BD\rightarrow E,B\rightarrow D,A\rightarrow D,E\rightarrow A\} F2={A→B,A→C,BD→E,B→D,A→D,E→A}，计算 ( B D ) F + = { } (BD)_F^+ = \{\} (BD)F+={}，所以C不冗余。
- 考察 B C D → E BCD\rightarrow E BCD→E中D是否冗余，即考察函数依赖集F是否逻辑蕴含函数依赖集 F 3 = { A → B , A → C , B C → E , B → D , A → D , E → A } F_3 = \{A\rightarrow B,A\rightarrow C,BC\rightarrow E,B\rightarrow D,A\rightarrow D,E\rightarrow A\} F3={A→B,A→C,BC→E,B→D,A→D,E→A}，计算 ( B C ) F + = { A B C D E } ⊇ E (BC)_F^+ = \{ABCDE\}\supe {E} (BC)F+={ABCDE}⊇E，所以D冗余。
去除冗余属性得 F 3 = { A → B , A → C , B C → E , B → D , A → D , E → A } F_3 = \{A\rightarrow B,A\rightarrow C,BC\rightarrow E,B\rightarrow D,A\rightarrow D,E\rightarrow A\} F3={A→B,A→C,BC→E,B→D,A→D,E→A}
step3：去除多余的函数依赖
对于函数依赖 A → D A\rightarrow D A→D，计算 ( A ) F 3 − ( A → D ) + = { A B C D E } ⊇ D (A)^+_{F_3-(A\rightarrow D)} = \{ABCDE\}\supe {D} (A)F3−(A→D)+={ABCDE}⊇D，所以函数依赖多余，去除得 F 4 = { A → B , A → C , B C → E , B → D , E → A } F_4 = \{A\rightarrow B,A\rightarrow C,BC\rightarrow E,B\rightarrow D,E\rightarrow A\} F4={A→B,A→C,BC→E,B→D,E→A}
step4：合并
F c a n o n c a l = { A → B C , B C → E , B → D , E → A } F_{canoncal} = \{A\rightarrow BC,BC\rightarrow E,B\rightarrow D,E\rightarrow A\} Fcanoncal={A→BC,BC→E,B→D,E→A}
2. 候选码的计算
算法：
例题
例1：
step1：X = {A}
step2： A F + = A A_F^+ = A AF+=A，所以单独的A不是候选码
step3： ( A B ) F + = U (AB)_F^+ = U (AB)F+=U，所以AB是候选码
( A C ) F + = U (AC)_F^+ = U (AC)F+=U，所以AC是候选码
( A E ) F + = U (AE)_F^+=U (AE)F+=U，所以AE是候选码
Y为空集
结束，所有的候选码为AB,AC,AE
2.1 候选码计算的应用
2.1.1 2NF的判断
2NF要求不存在非主属性对码的部分依赖，所以需要找出所有的候选码，确认非主属性，和是否有其对码的部分依赖的情况。
Example：R(A, B,C,D), F = {AB → C, AC → BD}
step1：求出所有的候选码
候选码集合为{AB, AC}
step2：非主属性，得到非主属性为D
step3：构造完整依赖： A B → D AB\rightarrow D AB→D和 A C → D AC\rightarrow D AC→D，判断这两个函数依赖中有无冗余属性。若无则不存在部分依赖，否则存在。
计算 ( A ) F + = ∅ (A)_F^+ = ∅ (A)F+=∅， ( B ) F + = ∅ (B)_F^+ = ∅ (B)F+=∅， ( C ) F + = ∅ (C)_F^+ = ∅ (C)F+=∅，即无冗余属性，所以不存在部分依赖，满足2NF
2.1.2 3NF的判断
3NF的计算也是需要计算出所有的候选码的。进而判断 β − α \beta-\alpha β−α的属性是不是在候选码中。
Example：R(A, B, C, D), F = {AB → C, C → D}，判断是否属于第三范式。
step1：候选码计算
( A B ) F + = U (AB)_F^+ = U (AB)F+=U，所以AB即是候选码。
step2：对于函数依赖 C → D C\rightarrow D C→D，对应 C ： α ， D ： β C：\alpha，D：\beta C：α，D：β，那么 β − α = D \beta-\alpha = D β−α=D不属于候选码
所以该范式非第三范式
3.Decomposition
3.1 无损分解和依赖保持的判定
Examples: R = ( A, B, C ) F = { A → B, B → C }
Decomposition1: R1 = (A, B), R2 = (B, C)
➢ IS Lossless-join ?
R
1
∩
R
2
=
B
B
→
R
2
成
立
，
所
以
该
分
解
为
L
o
s
s
l
e
s
s
−
J
o
i
n
D
e
c
o
m
p
o
s
i
t
i
o
n
R_1\cap R_2 = B\\ B\rightarrow R_2成立，所以该分解为Lossless-Join\ Decomposition
R1∩R2=BB→R2成立，所以该分解为Lossless−Join Decomposition
➢ IS Dependency preserving?
F
1
=
{
A
→
B
}
F
2
=
{
B
→
C
}
(
F
1
∪
F
2
)
+
=
F
+
,
所
以
该
分
解
是
依
赖
保
持
的
F_1 = \{A\rightarrow B\}\\ F_2 = \{B\rightarrow C\}\\ (F_1\cup F_2)^+=F^+,所以该分解是依赖保持的
F1={A→B}F2={B→C}(F1∪F2)+=F+,所以该分解是依赖保持的
Decomposition2: R1 = (A, B), R2 = (A, C)
➢ IS Lossless-join ?
R
1
∩
R
2
=
A
A
→
R
1
成
立
，
所
以
该
分
解
为
L
o
s
s
l
e
s
s
−
J
o
i
n
D
e
c
o
m
p
o
s
i
t
i
o
n
R_1\cap R_2 = A\\ A\rightarrow R_1成立，所以该分解为Lossless-Join\ Decomposition
R1∩R2=AA→R1成立，所以该分解为Lossless−Join Decomposition
➢ IS Dependency preserving?
F
1
=
{
A
→
B
}
F
2
=
{
A
→
C
}
(
F
1
∪
F
2
)
+
≠
F
+
,
所
以
该
分
解
不
是
依
赖
保
持
的
F_1 = \{A\rightarrow B\}\\ F_2 = \{A\rightarrow C\}\\ (F_1\cup F_2)^+≠F^+,所以该分解不是依赖保持的
F1={A→B}F2={A→C}(F1∪F2)+=F+,所以该分解不是依赖保持的
3.2 BCNF的无损分解
Examples:
emp_info ( emp_id, emp_name, epm_phone, dept_name, dept_phone, dept_mgrname, skill_id, skill_name, skill_date, skill_lvl )
Fc = { emp_id → (emp_name, epm_phone, dept_name ), dept_name → ( dept_phone, dept_mgrname) , skill_id → skill_name, (emp_id, skill_id , skill_date )→ skill_lvl }
CK: (emp_id, skill_id , skill_date )
要求：Decomposition to BCNF
step1：emp_id不是码，将emp_id决定的最大的关系模式取出，得到：
R1 = {emp_id, emp_name, epm_phone, dept_name, dept_phone, dept_mgrname}
有函数依赖：
F1 : {emp_id → emp_name, epm_phone, dept_name; dept_name → dept_phone, dept_mgrname}，
在原关系模式中去除右半部分，得到：
R2 = {emp_id, skill_id, skill_name, skill_date, skill_lvl}
有函数依赖：
F2 = {skill_id → skill_name, (emp_id, skill_id , skill_date)→ skill_lvl}
step 2 ：在R1中仍有dept_name不是超码，继续分解R1
R11 = {dept_name, dept_phone, dept_mgrname}
有函数依赖：
F11 : {dept_name → dept_phone, dept_mgrname}
满足BCNF范式
R12 = {emp_id, emp_name, epm_phone, dept_name}
有函数依赖：
F12 = {emp_id → emp_name, epm_phone, dept_name}
满足BCNF范式
step3：在R2中仍有skill_id不是超码，继续分解：
R12 = {skill_id, skill_name}
有函数依赖：
F21 = {skill_id → skill_name}
满足BCNF范式
R22 = {skill_id, skill_date, emp_id, skill_lvl}
有函数依赖：
F22 = {(emp_id, skill_id , skill_date)→ skill_lvl}
满足BCNF范式
至此所有的子模式均满足BCNF范式，分解完毕，结果为R11,R12,R21,R22
{skill_id, skill_name}`
有函数依赖：
F21 = {skill_id → skill_name}
满足BCNF范式
R22 = {skill_id, skill_date, emp_id, skill_lvl}
有函数依赖：
F22 = {(emp_id, skill_id , skill_date)→ skill_lvl}
满足BCNF范式
至此所有的子模式均满足BCNF范式，分解完毕，结果为R11,R12,R21,R22
1688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
