数据库作业

1、
为车辆保险公司构建一个E-R图，它的每个客户有一辆或多辆车。每辆车关联零次或任意次事故的记录。每张保险单为一辆或多辆车保险，并与一个或多个保费支付相关联。每次支付只针对特定的一段时间，具有关联的到期日和缴费日。

2、
为医院构建一个包含一组病人和一组医生的E-R图。为每个病人关联一组不同的检查和化验记录。

3、
为一个汽车公司设计一个数据库，用于协助它的经销商维护客户记录以及经销商库存，并协助销售人员订购车辆。
每辆车由车辆编号(Vehicle Identifcation Number,VIN)唯一标识，每辆单独的车都是公司提供的特定品牌的特定车型(例如，XF是塔塔汽车捷豹品牌的车型)。每个车型都可以有不同的选项，但是一辆车可能只有一些(或没有)可用的选项。数据库需要保存关于车型、品牌、选项的信息，以及每个经销商、顾客和车的信息。
你的设计应该包括E-R图、关系模式的集合，以及包括主码约束和外码约束的一组约束。
请将上述内容表示在一张jpg图片中，然后提交该jpg图片文件。

4、
设计一个E-R图用于跟踪记录你最喜欢的球队的成绩。你应该保存打过的比赛，每场比赛的比分，每场比赛的上场队员以及每个队员在每场比赛中的统计数据。总的统计数据应该被建模成派生属性。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

如果将模式R分解为：R1(A,B,C)与R2(A,D,E)。
证明该分解是无损分解。

答
如果R1∩R2→ R1或R1 n R2→ R2，则一个分解{R1, R2}是一个无损连接分解。
设R1=(A, B, C)， R2 =(A, D, E)， R1 ∩ R2 = A。因为A→BC => A→ABC，即R1 ∩ R2→R1，
因此该分解是无损连接分解。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

给出模式R的一个无损连接的BCNF分解。

答
R的候选码是A、E、CD、BC。
B→D中B不是R的超码，因此，R不是BCNF。
根据BCNF分解算法，将R分解为R1(B,D)和R2(A,B,C,E)。
R1上的函数依赖F1={B→D},R1满足BCNF。
R2上的函数依赖F2={A→BCE,E→ABC,BC→AE},R2满足BCNF。
最后，R的BCNF分解为：R1(B,D)与R2(A,B,C,E)。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

给出模式R的一个无损连接并保持依赖的3NF分解。

答
F的正则覆盖Fc={A→BC,CD→E,B→D,E→>A}
R的候选码是A、E、CD、BC。
根据3NF分解算法，将R分解：
A→BC =>  R1=(A, B, C)，
CD→E =>  R2=(C, D, E)，
B→D  =>  R3=(B, D)，
E→A  =>  R4=(E,A)，
R1...R4中已经包含了R的候选码，
因此，R的3NF分解为：R1(A,B,C),R2(C,D,E),R3(B,D),R4(A,E)

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

答
证明模式R的如下分解不是无损分解:
(A,B,C)

如果R1∩R2→ R1或R1 n R2→ R2，则一个分解{R1, R2}是一个无损连接分解。
设R1=(A,B,C)，R2 =(C,D,E)， R1 ∩ R2 = C。因C→BC与C→DE均不满足，即R1 ∩ R2→R1或R1 n R2→ R2均不满足，因此该分解不是无损连接分解。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

如果将模式R分解为：R1(A,B,C)与R2(A,D,E)。
证明该分解是无损分解。

如果R1∩R2→ R1或R1 n R2→ R2，则一个分解{R1, R2}是一个无损连接分解。
设R1=(A, B, C)， R2 =(A, D, E)， R1 ∩ R2 = A。因为A→BC => A→ABC，即R1 ∩ R2→R1，
因此该分解是无损连接分解。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A
给出模式R的一个无损连接的BCNF分解。

R的候选码是A、E、CD、BC。
B→D中B不是R的超码，因此，R不是BCNF。
根据BCNF分解算法，将R分解为R1(B,D)和R2(A,B,C,E)。
R1上的函数依赖F1={B→D},R1满足BCNF。
R2上的函数依赖F2={A→BCE,E→ABC,BC→AE},R2满足BCNF。
最后，R的BCNF分解为：R1(B,D)与R2(A,B,C,E)。

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A
给出模式R的一个无损连接并保持依赖的3NF分解。

F的正则覆盖Fc={A→BC,CD→E,B→D,E→>A}
R的候选码是A、E、CD、BC。
根据3NF分解算法，将R分解：
A→BC =>  R1=(A, B, C)，
CD→E =>  R2=(C, D, E)，
B→D  =>  R3=(B, D)，
E→A  =>  R4=(E,A)，
R1...R4中已经包含了R的候选码，
因此，R的3NF分解为：R1(A,B,C),R2(C,D,E),R3(B,D),R4(A,E)

假设有关系模式R(A,B,C,D,E)，如下函数依赖集F成立:
   A→BC，CD→E，B→D，E→A

证明模式R的如下分解不是无损分解:
(A,B,C)
(C,D,E)

如果R1∩R2→ R1或R1 n R2→ R2，则一个分解{R1, R2}是一个无损连接分解。
设R1=(A,B,C)，R2 =(C,D,E)， R1 ∩ R2 = C。因C→BC与C→DE均不满足，即R1 ∩ R2→R1或R1 n R2→ R2均不满足，
因此该分解不是无损连接分解。

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

计算B的闭包。

设 result=B；
由于B->D,故result=B∪D=BD；
由于D->A,故result=BD∪A=ABD；
由于A->BCD,故result=ABD∪BCD=ABCD；
由于BC->DE,故result=ABCD∪DE=ABCDE;
最终结果：B的闭包为ABCDE

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

(使用Armstrong公理)证明AF是超码。

由于A->BCD，故A->ABCD(增补率，两边增补A)
由于BC->DE，故ABCD->ABCDE(增补率，两边增补ABCD)
因此A->ABCDE(传递率)
因此AF->ABCDEF(增补率，两边增补F)
因为AF可以推出所有属性，即AF的闭包包含所有属性，故AF是超码

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

计算上述函数依赖集F的正则覆盖；给出你的推导的步骤并解释。

首先观察可知无左侧元素相同的可合并的函数依赖，因此查看无关属性。
由于B->D，因此在A->BCD和BC->DE中D均为无关属性(A->B,B->D,故A->D，因此A->BC结合A->D可以推出A->BCD；
B->D故BC->D，因此BC->E结合BC->D可以说明BC->DE；因此D为无关属性)，因此式子可以简化为：
A->BC BC->E B->D D->A
由于B->D,D->A,A->BC,因此B->C,因此BC->E中C为无关属性，因此可简化为：
A->BC B->E B->D D->A
左侧为B的有两项，可合并：
A->BC B->DE D->A
发现当前无无关属性，因此此时即为F的正则覆盖

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

基于正则覆盖，给出R的一个3NF分解。

由于正则覆盖中没有多余的函数依赖，因此属性集是正则覆盖中其他函数依赖组成的子集，
因此这里的三个函数依赖都有自己的关系：R1(A,B,C)、R2(B,D,E)、R3(D,A) 然后我们发现属性F并不在其中，
因为AF是超码且上述的关系中并没有原关系的超码，因此需要添加 R4(A,F)
因此最终结果为：R1(A,B,C)、R2(B,D,E)、R3(D,A)、R4(A,F)

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

利用原始的函数依赖集，给出R的一个BCNF分解。

start: R={A,B,C,D,E,F}
由于A->BCD但A不是超码，故R不满足BCNF,进行分解：
step1: R= R1(A, B, C, D),R2(A, E, F)
由于A->E是F+中的函数依赖，因此R2不满足BCNF,进行分解
step2: R=R1(A, B, C, D),R2(A, F),R3(A, E)
检验可得现在均符合BCNF

考虑如下关系模式R(A,B.C.D,E,F)上的函数依赖集F:
{A→BCD，BC→DE，B→D，D→A}

你能否利用正则覆盖得到与上面的R相同的BCNF分解?

若想通过正则覆盖得到与上面R相同的BCNF分解，直接进行BCNF分解是不行的，
需要通过从正则覆盖推断出原始函数依赖并将其进行BCNF分解才能够得到相同的BCNF分解

丢失更新(lost update)异常是指如果事务Tj读取了一个数据项，
然后另一个事务Ti写该数据项(可能基于先前的读取)，然后Tj写该数据项。
于是Ti做的更新丢失了，因为Tj的更新覆盖了Ti写入的值。

给出一个表示丢失更新异常的调度实例。

T1            T2
read(A)
            read(A)
            write(A)
write(A)

答案二
R1(A)R2(A)W2(A)W1(A)

或者以表格的形式表示：
T1         T2
-----------------
Read(A)
          Read(A)
          Write(A)
Write(A)
在上面的调度中，事务T2写入的值由于事务T1的写入而丢失。

丢失更新(lost update)异常是指如果事务Tj读取了一个数据项，
然后另一个事务Ti写该数据项(可能基于先前的读取)，然后Tj写该数据项。
于是Ti做的更新丢失了，因为Tj的更新覆盖了Ti写入的值。

给出一个表示丢失更新异常的调度实例，表明在已提交读隔离性级别下该异常也可能存在。

T1           T2
lock-S(A)
read(A)
unlock(A)
             lock-X(A)
             read(A)
             write(A)
             unlock(A)
             commit
lock-X(A)
write(A)
unlock(A)
commit


答案二
T1         T2
-----------------
Lock-S(A)
Read(A)
unlock(A)
          Lock-X(A)
          Read(A)
          Write(A)
          unlock(A)
          commit
Lock-X(A)
Write(A)
unlock(A)
commit

上述调度中的封锁确保了已提交读隔离性的级别。但由事务T2写入的值因T1的写入而丢失。

丢失更新(lost update)异常是指如果事务Tj读取了一个数据项，
然后另一个事务Ti写该数据项(可能基于先前的读取)，然后Tj写该数据项。
于是Ti做的更新丢失了，因为Tj的更新覆盖了Ti写入的值。

解释为什么在可重复读隔离性级别下丢失更新异常不可能发生。

在可重复读隔离性下，一个事件T1读取一个数据x，直到最后都有一个共享的锁在x上，
在T1结束前，这就不可能有一个新的事件T2去修改数据x的值，所以按T1，T2的顺序执行，
所以T2写的数据没有丢失。

答案二
在可重复读取隔离级别，不会出现丢失更新异常。
在可重复读取隔离级别中，事务T1读数据项X，在X上持有一个共享锁，直到事务结束。
这使得较新的事务T2要等到T1结束才能够写X的值。
这就强制成串行顺序T1、T2，因此T2所写的值不会丢失。

考虑下面两个事务:
T1：read(A)      
    read(B)
    if A=O then B:=B+1
    write(B)

T2：read(B)
    read(A)
    if B=O then A:=A+1
    write(A)


给事务T1与T2增加加锁、解锁指令，使它们遵从两阶段封锁协议。

T1: 
lock-S(A)
read(A)
lock-X(B)
read(B)
if A = 0 then B := B + 1
write(B)
unlock(A)
unlock(B)

T2: 
lock-S(B)
read(B)
lock-X(A)
read(A)
if B = 0 then A := A + 1
write(A)
unlock(B)
unlock(A)



答案二
T1：lock-S(A)      
    read(A) 
    lock-X(B)     
    read(B)
    if A=O then B:=B+1
    write(B)
    unlock(A)     
    unlock(B)     

T2：lock-S(B)      
    read(B) 
    lock-X(A)     
    read(A)
    if B=O then A:=A+1
    write(A)
    unlock(B)     
    unlock(A) 

考虑下面两个事务:
T1：read(A)      
    read(B)
    if A=O then B:=B+1
    write(B)

T2：read(B)
    read(A)
    if B=O then A:=A+1
    write(A)


这两个事务会引起死锁吗? 

会，例如
T31          T32
lock-S(A)
             lock-S(B)
             read(B)
read(A)
lock-X(B)
             lock-X(A)


答案二
执行这些事务可能导致死锁。例如，考虑以下调度：
T1         T2
-----------------
Lock-S(A)
Read(A)
          Lock-S(B)
          Read(B)
Lock-X(B)
          Lock-X(A)

此时调度出现了死锁。

考虑下面两个事务:
T1：read(A)      
    read(B)
    if A=O then B:=B+1
    write(B)

T2：read(B)
    read(A)
    if B=O then A:=A+1
    write(A)
 
设一致性需求为A=0 ∨ B=0，初值是A=B=0。

说明包括这两个事务的每一个串行执行都保持数据库的一致性。

有两种可能，T1T2和T2T1，
     A B
初始 0 0
T1   0 1
T2   0 1
符合一致性要求 A=0 ∨ B=0
     
     A B
初始 0 0
T1   1 0
T2   1 0
符合一致性要求 A=0 ∨ B=0

答案二
T1与T2有2种可能的串行调度：T1、T2，或者T2、T1。
对于调度T1、T2，调度结束时，A=0，B=1
对于调度T2、T1，调度结束时，A=1，B=0
可以看出串行执行会生成两种不同的结果，但都保持了数据库的一致性。

考虑下面两个事务:
T1：read(A)      
    read(B)
    if A=O then B:=B+1
    write(B)

T2：read(B)
    read(A)
    if B=O then A:=A+1
    write(A)
 
设一致性需求为A=0 ∨ B=0，初值是A=B=0。

给出T1和T2的一次并发执行，执行产生不可串行化调度。

T1                       T2
read(A)                    
                          read(B)
                          read(A)

read(B)
if A = 0 then B := B + 1 
                          if B = 0 then A := A + 1
                          write(A)

write(B)

答案二
T1和T2的如下并发执行，将产生不可串行化调度：
T1                 T2
----------------------------
Read(A)
                   Read(B)
                   Read(A)
Read(B)
if A=O then B:=B+1
                   if B=O then A:=A+1
                   Write(A)
Write(B)

考虑下面两个事务:
T1：read(A)      
    read(B)
    if A=O then B:=B+1
    write(B)

T2：read(B)
    read(A)
    if B=O then A:=A+1
    write(A)
 
设一致性需求为A=0 ∨ B=0，初值是A=B=0。

存在产生可串行化调度的T1和T2的并发执行吗?

不存在可串行化调度的T1和T2的并行执行。我们知道，一个可串行化的时间表会导致A=0 ∨ B=0。
假如我们从T1 read（a）开始。然后，当计划结束时，无论何时我们运行T2的步骤，B=1。
现在假设我们在T1完成之前开始执行T2。那么T2 read（B）将给B一个值0。
当T2完成时，A=1，因此B=1∩A=1。从T2 read（B）开始也同上过程。

答案二
不存在产生可串行化调度的T1和T2的并发执行。
如果存在产生可串行化调度的T1和T2的并发执行，则其等价于串行调度T1、T2或T2、T1。
我们可以通过交换串行调度中相邻的非冲突操作对的执行顺序，得到可串行化调度的并发执行。
但不存在这种相邻的非冲突操作对。

什么是可恢复调度?

一个可恢复调度满足：对于每对事务Ti和Tj，如果Tj读取了之前由Ti所写的数据项，则Ti先于Tj提交。

答案二
假设在一个调度中，Tj读取了Ti写入的数据，Ti在提交前发生故障，我们必须中止Tj以保证事务地原子性。若Tj在Ti出现故障后是可中止的，那么我们就称该调度是可恢复调度。
可恢复调度应满足:对于每个事务Ti和Tj，如果Tj读取了由Ti所写的数据项，则Ti先于Tj提交。