精华内容
下载资源
问答
  • 数据库函数依赖

    2014-09-25 10:54:40
    函数依赖简单地说就是属性A推导出属性B,比如 给定这些规则之后,如果某个关系能够满足给定的函数依赖,则称关系R满足函数依赖F;   在下面我们会介绍一系列的范式以及分解算法;   函数...

    如果我们要设计关系型数据库的表模式,则很有可能会出现冗余,为了避免这种情况,我们需要一些规则,这些规则称为依赖。

    函数依赖简单地说就是属性集A推导出属性集B,比如

    给定这些规则之后,如果某个关系能够满足给定的函数依赖,则称关系R满足函数依赖F;

     

    在下面我们会介绍一系列的范式以及分解算法;

     

    函数依赖的分解合并规则

     

     

    是等价的(可以互相转化的),第一个式子替换第二个式子称为合并规则,第二个式子替换第一个式子称为分解规则;

    平凡函数依赖:如果A-->B,A是B的超集,则称此函数依赖为平凡的。

    平凡依赖规则:如果A-->B,则可以将其变为A-->(B-A∩B),这样可以消除冗余;

     


    键的函数依赖定义:

     

    (1)如果存在某个属性集,能够蕴含全部的属性;

    (2)这个属性集的任意真子集都不能蕴含全部属性;

    则称这个属性集为键;

     

    函数依赖习题

     

     

    平凡依赖规则

     

     

     

    举例:name,age --->name,course, 根据平凡依赖规则,可以简化为 name,age -->course.

     

    异常

     

    如果一个关系的模式没有设计好,则会出现异常。异常的类型为:

    (1)冗余:一个属性的值多次出现,比如:

    (2)更新异常:上图的关系就存在更新异常,因为如果需要更新database这门课为database concept,则需要将左边的database全部更新为database concept;

    (3)删除异常:上图的关系存在删除异常,因为将Avi、Hank、Sudarshan老师删除,则会出现database这门课消失了,但实际上数据库这门课永远不会消失,而只是老师辞职了。



    属性闭包算法

     

     

     

    举例:

     

     

     

    闭包的应用

     

    1.给定函数依赖集F1,是否可以推断出函数依赖f:A-->B?

     

    只需要求出{A}+是否包含B,如果包含,则说明F1能够推断出f,否则不能;

    举例:

     

    2.判断某个属性集是否为键?

     

    如果要证明属性集是超键,则只需要计算此属性集的闭包,看闭包中是否包含全部的属性;

    但是如果需要证明属性集是候选键,则第一步需要证明是超键,第二步需要证明从属性集中任意去掉一个属性,此属性集就不是超键; 

     

    3.给出一些术语.

     

    给定一个函数依赖集A;

    A的基本集:和A等价的函数依赖集;

    A的最小化基本集:满足(1)函数依赖的右边只有单个属性(2)删除任意一个函数依赖都不将是基本集(3)从函数依赖的左边删除任意一个属性,则不将是基本集;

     

     

     

    4.投影函数依赖

     

    给定一个关系和满足的函数依赖F,求对部分属性投影后,哪些函数依赖满足。

    比如:原本属性为A,B,C的关系,投影到A,B后,还有哪些函数依赖成立?

    简单地说就是:

    (1)首先计算单属性的闭包,比如{A}的闭包为{B,C},如果我们的投影为{A,B},则需要包含A-->B,而不包含A-->C;(如果存在某个属性集能够蕴含所有属性,则我们就不需要再求此属性集的闭包)

    (2)接着计算双属性,三属性,四属性.....;

    (3)在求出的基本集中最小化;

               --如果投影后的某个函数依赖能够通过投影后的其他函数依赖推出,则删除;

                          比如:{A-->C,A-->B,B-->C},删除A-->C,因为此函数依赖能够通过其他函数依赖推导;

               --如果某个函数依赖A-->B,删除A中某个属性后仍然在投影的函数依赖中成立,则删除;

                          比如:投影后的函数依赖为{AC-->B,A-->B},则把{AC-->B}删除,因为如果删除C即A-->B 能够从投影的函数依赖中推出;

     

    举例:

     


    5.判断无损分解

     

    如果R1∩R2是R1或R2的超码,则R上的分解(R1,R2)是无损分解。



    Armstrong公理

     


    下面我们会说到BCNF分解和3NF分解,而分解也是有评判标准的:

    (1)消除异常;

    (2)无损连接:分解后再连接是否和原来的关系一致;

                用chase检验法则;

    (3)保持依赖:FD的投影在分解后的关系上成立,但是连接后的关系不满足原始FD;

    BCNF满足(1)和(2),3NF满足(1)(2)(3)


    Chase检验法则

     

    判断分解后再自然连接是否还是原始的关系;


    思想:自然连接后的每个元组都属于原始关系;

    如果将关系投影到Si后再进行自然连接,就会得到一个所有分量都不带下标的元组,这个元组不在R中,则连接为无损的;

     

    举例:

     


    保持依赖

     

    思想:FD投影在分解的关系中成立,但是自然连接后不能满足原始的FD

     

    举例:

     


    BCNF

     

    当关系满足如果R中非平凡的函数依赖的左边都是超键,则此关系R属于BCNF;

     

    性质:任何一个二元关系都满足BCNF

     

    证明:如果函数依赖集中存在A-->B,则我们可以说A-->AB,因此A一定是超键;

     

    BCNF分解

     

    注:BCNF分解是无损分解

     

    while(找到违反BCNF的函数依赖){

        找出违反BCNF的函数依赖A-->B,先计算A的闭包,且用A的闭包(除去A)替换B,并将其分解为{A+}和{AU(R-(A+)};   //比如A-->B ,而{A}+={A,B,C},则用A-->BC替换A-->B;

        求出分解后的关系满足的投影FD集合;

        再看分解后的关系的FD集合是否满足BCNF,如果不满足,则继续分解。

    }

    举例:


    3NF

     

    注:3NF是能够无损连接且保持依赖;

     

    放松了BCNF的要求,多出的一个条件为:如果A-->B,则B-A为候选键的一部分(即使在不同的候选键中),则满足3NF;

    这里我们对上句中的红色标注部分进行解释,看一个例子:

    比如:存在函数依赖A-->BC,{AB}{AC}分别为候选键,而BC-A={BC},B属于候选键{AB},C属于候选键{AC},但是A-->BC仍然满足3NF;

     

    主属性:一个属性属于某个候选键;

    比如:{AC}为候选键,则A为主属性,C也为主属性;

     

    3NF分解算法

     

     

    举例:



    1NF

     

    每个属性都保持原子性;

     

    2NF

     

    满足1NF,且每一个非主属性都完全函数依赖于R的主码;


    多值依赖

     

    引入多值依赖的原因

     

     

     

    从上图中可以知道,此关系的候选键为(name,street,city,title,year),因此不存在任何非平凡的函数依赖,因此遵守BCNF,但是我们可以很容易看出,(street、city)和(title、year)是独立的;放在一个关系中是冗余的;

    因此多值依赖的产生就是源于此;我们可以将上图的关系根据4NF分解算法分解关系;

     

    多值依赖(MVD)定义

     

    A1A2....An-->-->B1B2....Bm,则说明

    (1)给定A1A2...An的值,B1B2...Bm属性独立于(U-A-B)属性;

    (2)给定R中的两个元组a、b,他们的A属性相同,则必然存在第三个元组c,使得c[A]=a[A]=b[A],c[B]=a[B],c[U-A-B]=b[U-A-B];

     

     

     

    多值依赖性质

     

    (0)多值依赖其实就是FD的升级,即如果A-->B成立,则A-->-->B也成立;

    (1)平凡MVD:如果B是A的子集,则A-->-->B成立;

    (2)附加平凡MVD:如果关系R(A,B),则A-->-->B成立;

    (3)传递MVD:如果A-->-->B,B-->-->C,则A-->-->C成立;

    (4)MVD不满足分解规则:

    (5)如果A-->-->B,则A-->-->(R-A-B)成立;


    4NF

     

    应用于MVD,而不是一般的FD;条件和BCNF差不多;

    定义:如果存在非平凡的A-->-->B,且A一定是超键,则为4NF;

     

    4NF分解算法

     

    1.找违反4NF的MVD;

    2.按照A-->-->B 分解为{AB} {R-A-B};

    3.计算投影FD;

    4.继续找违反的MVD,分解.....;

     

    总结:

     

     

    展开全文
  • 关系数据库理论之最小函数依赖集

    万次阅读 多人点赞 2019-04-06 23:38:53
    在本文中,会介绍为什么要引入最小函数依赖集,最小函数依赖集是什么,以及如何求最小函数依赖集。 为什么需要最小函数依赖集 在关系数据模型中,一个关系通常由R(U,F)构成,U为属性的全集,F为函数依赖集。在实际...

    前言

    在本文中,会介绍为什么要引入最小函数依赖集,最小函数依赖集是什么,以及如何求最小函数依赖集。

    为什么需要最小函数依赖集

    在关系数据模型中,一个关系通常由R(U,F)构成,U为属性的全集,F为函数依赖集。在实际生活中,我们可以根据语义来定义关系中属性的依赖关系,例如学号可以唯一确定一位学生的姓名、性别等等。但是,有时候给出的函数依赖集并不是最简的,这有时会拖累我们对关系的后续处理,例如关系的分解、判断是否为无损分解等。所以,我们在必要时,需要对函数依赖集进行化简,这就是需要最小函数依赖集的原因。
    在正式介绍最小函数依赖集之前,还需要了解一个概念,那就是闭包。准确的说是属性集X关于函数依赖集F的闭包

    闭包

    闭包分为两种,一种是函数依赖集F的闭包,另外一种是属性集X关于函数依赖集F的闭包。前者不做讨论,重点说说后者。先来看定义

    F为属性集U上的一组函数依赖集,XY \inUXF+X_F^+= {A|X\rightarrowA能由F根据Armstrong公理导出},XF+X_F^+称为属性集X关于函数依赖集F的闭包。

    说白了,就是给定属性集X,根据现有的函数依赖集,看其能推出什么属性。
    这里的Armstrong公理系统不用深究,想具体了解的可以点击查看百度百科。
    举例:

    已知关系模式R<U,F>,其中:
    U = {A,B,C,D,E},
    F = {AB \rightarrow C,B\rightarrowD,C\rightarrowE,EC\rightarrowB,AC\rightarrowB}
    (AB)F+(AB)_F^+

    解:

    从AB出发,此时我们的集合里已经包含了{A,B}。
    我们从现有的函数依赖集中可知,
    AB可以推出C,于是C加入集合,
    B可以推出D,于是D加入集合,
    C可以推出E,于是E加入集合,
    EC可以推出B,因为C、E、B都在集合中,于是不加入,
    AC可以推出B,因为A、B、C都在集合中,于是不加入
    至此,可求得(AB)F+(AB)_F^+ ={A、B、C、D、E}。

    最小函数依赖集

    定义

    如果函数依赖集F满足下列条件,则称F为一个极小函数依赖集,亦称为最小依赖集最小覆盖
    (1)、F中任一函数依赖右部仅含有一个属性。
    (2)、F中不存在这样的函数依赖 X\rightarrowA,使得FF-{X\rightarrowA} 等价。
    (3)、F中不存在这样的函数依赖X\rightarrowAX有真子集Z使得F-{X\rightarrowA}\bigcup{Z\rightarrowA}F等价。

    解释

    以上定义翻译成大白话就是,一个函数依赖集F要想称为最小函数依赖集,要满足以下三点:
    1、F中任一函数依赖的右边只有一个属性。
    2、F中不存在这样的函数依赖:从现有的函数依赖集中删除一个函数依赖X\rightarrowA,删除后所得的函数依赖集与原来的函数依赖集等价,这样的函数依赖是不允许存在的。
    3、F中不存在这样的函数依赖:假设函数依赖集中存在AB\rightarrowY,现对该依赖的左部进行化简,即删除A,得B\rightarrowY;或删除B,得A\rightarrowY,若经过化简后的函数依赖集与没有化简前的函数依赖集等价,那么这样的函数依赖是不允许存在的。

    算法

    1、首先,先利用函数依赖的分解性,将函数依赖集中右部不为单个属性的分解为单属性。

    2、对于经过第1步筛选后的函数依赖集F中的每一个函数依赖X\rightarrowA,进行以下操作:

    • 2.1、将X\rightarrowA从函数依赖中剔除
    • 2.2、基于剔除后的函数依赖,计算属性X的闭包,看其是否包含了A,若是,则该函数依赖是多余的(这里体现出前面说的等价,因为如果基于化简后的函数依赖依赖,计算X的闭包依然包含A,则说明A可以由其他依赖推出,X\rightarrowA不是必须的),可以删除,否则不能删除

    3、对于经过第2步筛选后的函数依赖集F中每个左部不为单个属性的函数依赖AB\rightarrowY,进行以下操作:
    我们约定,经过第二步筛选后的函数依赖集记为F1,经过第三步处理后的函数依赖集为F2。

    • 3.1、去除A,得B\rightarrowY,得F2,基于F1和F2计算属性B的闭包,如果二者相等,则说明它们是等价的,A可以去除;如果不相等,则A不能去除。
    • 3.2、去除B,得A\rightarrowY,得F2,基于F1和F2计算属性A的闭包,如果二者相等则说明它们是等价的,B可以去除;如果不相等,则B不能去除。

    知识链接:函数依赖的分解性
    若X\rightarrowYZ,则X\rightarrowY 且 X\rightarrowZ。

    举例

    关系模式R(U,F)中,U={A,B,C,D,E,G},F={B\rightarrowD,DG\rightarrowC,BD\rightarrowE,AG\rightarrowB,ADG\rightarrowBC};求F的最小函数依赖集。

    解:
    1、首先根据函数依赖的分解性,对F进行第一次筛选,需要变动的有:
    ADG\rightarrowBC拆解成ADG\rightarrowB、ADG\rightarrowC
    得新函数依赖集:
    F = {B\rightarrowD,DG\rightarrowC,BD\rightarrowE,AG\rightarrowB,ADG\rightarrowB,ADG\rightarrowC}

    2、筛选多余的函数依赖

    • 2.1:去除B\rightarrowD,得F = {DG\rightarrowC,BD\rightarrowE,AG\rightarrowB,ADG\rightarrowB,ADG\rightarrowC},BF+B_F^+ = {B},不包含D,故B\rightarrowD不删除。
    • 2.2:去除DG\rightarrowC,得F = {B\rightarrowD、BD\rightarrowE,AG\rightarrowB,ADG\rightarrowB,ADG\rightarrowC},(DG)F+(DG)_F^+={D,G},不包含C,故DG\rightarrowC不删除。
    • 2.3:去除BD\rightarrowE,得F = {B\rightarrowD,DG\rightarrowC,AG\rightarrowB,ADG\rightarrowB,ADG\rightarrowC},(BD)F+(BD)_F^+ = {B,D},不包含E,故BD\rightarrowE不删除。
    • 2.4:去除AG\rightarrowB,得F = {B\rightarrowD,DG\rightarrowC,BD\rightarrowE,ADG\rightarrowB,ADG\rightarrowC},(AG)F+(AG)_F^+ = {A,G},不包含B,故AG\rightarrowB不删除。
    • 2.5:去除ADG\rightarrowB,得F = {B\rightarrowD,DG\rightarrowC,BD\rightarrowE,AG\rightarrowB,ADG\rightarrowC},(ADG)F+(ADG)_F^+ = {A,D,G,C,B,E},包含B,故ADG\rightarrowB去除
    • 2.6:去除ADG\rightarrowC,得F = {B\rightarrowD,DG\rightarrowC,BD\rightarrowE,AG\rightarrowB,ADG\rightarrowB},(ADG)F+(ADG)_F^+ = {A,D,G,C,B,E},包含C,故ADG\rightarrowC去除
      经过第二部筛选后,函数依赖集F变为{B\rightarrowD,DG\rightarrowC,BD\rightarrowE,AG\rightarrowB}。

    3、化简函数依赖左侧不为单个属性的函数依赖

    • 3.1:先看DG\rightarrowC
      • 3.1.1:去除D,得G\rightarrowC,得函数依赖集F1 = {B\rightarrowD,G\rightarrowC,BD\rightarrowE,AG\rightarrowB}。
        基于F1,可求得GF+G_F^+ = {G,C}。
        基于F(第二步求出的,下同),可求得GF+G_F^+ = {G}
        可见二者并不相同,所以D不去除。
      • 3.1.2:去除G,得D\rightarrowC,得函数依赖集F1 = {B\rightarrowD,D\rightarrowC,BD\rightarrowE,AG\rightarrowB}
        基于F1,可求得DF+D_F^+ = {D,C}
        基于F,可求得DF+D_F^+ ={D}
        可见二者并不相同,所以G不去除。

    综上,DG\rightarrowC,已是最简。

    • 3.2:再看BD\rightarrowE
      • 3.2.1:去除B,得D\rightarrowE,得函数依赖集F1 = {B\rightarrowD,DG\rightarrowC,D\rightarrowE,AG\rightarrowB}
        基于F1,可求得DF+D_F^+ = {D,E}
        基于F,可求得DF+D_F^+ = {D}
        可见二者并不相同,所以B不去除。
      • 3.2.2:去除D,得B\rightarrowE,得函数依赖集F1 = {B\rightarrowD,DG\rightarrowC,B\rightarrowE,AG\rightarrowB}
        基于F1,可求得BF+B_F^+ = {B,E,D}
        基于F,可求得BF+B_F^+ = {B,D,E}
        可见二者相同,所以D可以去除

    综上,BD\rightarrowE,可化简为B\rightarrowE。

    • 3.3:最后看AG\rightarrowB
      • 3.3.1:去除A,得G\rightarrowB,得函数依赖集F1 = {B\rightarrowD,DG\rightarrowC,B\rightarrowE,G\rightarrowB}
        基于F1,可求得GF+G_F^+ = {G,B}
        基于F,可求得 GF+G_F^+ = {G}
        可见二者并不相同,所以A不可去除。
      • 3.3.2:去除G,得A\rightarrowB,得函数依赖F1 = {B\rightarrowD,DG\rightarrowC,B\rightarrowE,A\rightarrowB}
        基于F1,可求得AF+A_F^+ = {A,B}
        基于F,可求得AF+A_F^+ = {A}
        可见二者并不相同,所以G不可去除。

    综上,AG\rightarrowB,已是最简。
    综上,R的最小函数依赖集为F = {B\rightarrowD,DG\rightarrowC,B\rightarrowE,AG\rightarrowB}

    写在最后

    这个问题是我在考研复试的时候复习过程中遇到的,主要的纠结点在于第三步的判断上,查资料的时候发现网上很多都没有写清,最后还是在度娘的文库里找到了比较清楚的解释,在此做一下思路的整理。
    本文定义以及例子参考自:

    展开全文
  • 1.数据库函数依赖 函数依赖是数据依赖的一种形式,它反映属性或属性组之间相互依存、互相制约的关系,即反映现实世界的数据约束关系。 在数据库设计中,函数依赖是指一个关系表中属性之间的依赖关系。 函数依赖...

    1.数据库函数依赖

    函数依赖是数据依赖的一种形式,它反映属性或属性组之间相互依存、互相制约的关系,即反映现实世界的数据约束关系。

    在数据库设计中,函数依赖是指一个关系表中属性之间的依赖关系。

    函数依赖类型:

    (1)完全函数依赖与部分函数依赖:

             定义:设X、Y是某关系的不同属性集,如X->Y,且不存在X'属于X,使X‘->Y,则Y称完全函数依赖,否则称Y部分函数依赖。

              X->Y称为Y函数依赖于X,即已知X,可以通过X推出Y。

              对于关系R( A , B , C , D , E),其中( A , B )为复合主键,若其他属性C,D,E都完整依赖于该复合主键,则称关系R为完全函数依赖,反之,其他属性C,D,E只依赖于A,或者只依赖于B,则称R为部分函数依赖。

    (2)属性传递依赖:

             定义:设X、Y、Z是某关系的不同属性集,X->Y, Y->X,Y->Z,则称Z对X存在函数传递依赖。

             对于关系R(A , B , C , D )其中X为主键,若属性B依赖于A,而A不依赖于B,属性C依赖于B,则属性C函数传递依赖于A。

    (3)多值函数依赖:设U是关系模式R的属性集,X和Y是U的子集,Z=U-X-Y,xyz表示属性集XYZ的值。对于R的关系r,在r中存在元组(x,y1,z1)和(x,y2,z2)时,也存在元组(x,y1,z2)和(x,y2,z1),那么在模式R上存在多值函数依赖。

            即是在关系R(A,B,C,D,E)中对于复合主键(A,B)给定值(a1,b1)对应值既有(a1,b1,c1,d1,e1)也有(a1,b1,c2,d1,e1)即为多值函数依赖。 关系规范化范式

     

    2.关系规范化:是把一个有访问异常的关系分解成更小的、结构良好的关系的过程,使得这些关系有最小的冗余或没有冗余。

    规范化范式(Normal Forma,NF)是指关系表的规范化程度状态。

    (1)第一范式(1NF):如果关系中的属性不可再细分,该关系满足第一范式

    (2)第二范式(2NF):如果关系满足第一范式,并消除了关系中的属性部分函数依赖,该关系满足第2范式。

    (3)第三范式(3NF):如果关系满足第二范式,并切断了关系中的属性传递函数依赖,则该关系满足第三范式。

    (4)BCNF范式:在关系中,所有函数依赖的决定因子都是候选键,该关系满足BCNF范式【复合主键中不存在函数依赖关系】

    (5)第四范式(4NF):如果关系满足BCNF范式,并消除了多值函数依赖,则关系满足第四范式。
     

    2.数据库关系模型:

    关系模型的约束完整性:

    实体完整性 在基本关系表中实施的主键取值约束吗,保证关系中的每个元组都可以被标识

    (1)主键属性不允许为空值

    (2)主键取值唯一

    参照完整性 关系之间需要遵守的数据约束,以保证关系之间的关系列的数据一致性 (1)外键取值必须与主键对应
    用户自定义完整性 用户根据具体业务对数据处理规则要求所定义的数据约束

    (1)定义列的数据类型和取值范围

    (2)定义列的缺省值

    (3)定义列是否允许取空值

    (4)定义列取指唯一性

    (5)定义列之间的数据依赖性

    3.事务并发

    (1)事务并发执行遇到的问题:脏读、幻影读、不可重复读:

    丢失更新数据 当多个事务并发存取共享数据时,由于不当的操作时序,可能出现数据不一致性问题
    不可重复读 一个事务对一个共享数据重复多次读取,但前后读取的数据不一致
    幻象读取 事务T1按一定条件从数据库中读取某些记录后,事务T2插入了一些记录,当T1再次按照相同条件读取数据时,发现多了一些记录,称为幻象读取
    脏数据读取 一个事务读取了被取消持久化的共享数据【回滚】

     

     

    (2)数据库的两段锁的解释:

              1) 一个给定的并发事务调度,当且仅当它是可串行化时,才能保证正确调度,二阶段锁定协议就是保证可串行化的协议。

              2)二阶段锁定协议规定每个事务必须分为两个阶段提出加锁和解锁申请

              3)增长阶段,事务只能获得锁,不能释放锁。

              4)缩减阶段,事务只能释放锁,但不能获得新锁。

    展开全文
  • 数据库函数依赖思路整理

    千次阅读 热门讨论 2014-09-14 20:24:20
    一个关系模式的所有函数依赖构成的集合就是函数依赖集,可以从这个函数依赖集中推导出来某个函数依赖(不包含在这个函数依赖集中),就说这个函数依赖集逻辑蕴涵这个函数依赖。 比如说:我们可以从有个
    
    

        由于这一知识点看的有点费劲,所以在此整理一下自己的思路。下边是我对一些新的概念和名词的理解。

    定义

        简单来看就是:一个属性集的值可以决定另一个属性集的值,当某个属性集的值确定以后另一个属性集的值也就确定了。


    逻辑蕴涵

        一个关系模式的所有函数依赖构成的集合就是函数依赖集,可以从这个函数依赖集中推导出来某个函数依赖(不包含在这个函数依赖集中),就说这个函数依赖集逻辑蕴涵这个函数依赖。

    比如说:我们可以从有个X集合包含2*2=44+5=9,我们可以从X中推导出算式Y2*2+5=9那么就说X逻辑蕴涵Y


    闭包

        能够推导出的所有函数依赖的集合就是闭包。


    关键码→FD

        其实关键码的概念就是一个特殊的FD只是将关键码的概念用FD来表示罢了。


    最小依赖集

        顾名思义就是要最小化(去掉多余的),函数依赖集中有很多函数依赖,但是在这个函数依赖集中可以用某几个函数依赖推导出另一些函数依赖,将能够推导出来的函数依赖从依赖集中去掉后剩下的就构成了这个函数依赖集的最小依赖集。

           其中还有部分知识点理解不到位,在接下来的学习中慢慢深入,相信会有新的发现。

    展开全文
  • 数据库函数依赖名词的解释

    千次阅读 2020-06-18 15:17:06
    平凡函数依赖:当属性Y是属性X的子集时,必然存在函数依赖X→Y,这种类型称为平凡的函数依赖 有函数A、B,B是A的子集(即B里面的内容,A都有,但A的内容B不一定有),即一定有 A → B 非平凡函数依赖:如果Y...
  • 数据库求最小函数依赖集

    万次阅读 多人点赞 2019-03-01 16:26:50
    ,U={A,B,C,D,E},F={A→BC,ABD→CE,E→D},求F的最小依赖集。 第一步:将F中所有函数依赖的右边化为单一属性。得到F1={A→B,A→C,ABD→C,ABD→E,E→D}。 第二步:将第一步得到的F1去除其中的冗余依赖...
  • 数据库:最小函数依赖集

    千次阅读 2019-05-21 20:11:04
    1.对于函数依赖的右端,将其分解为单个属性...2.对于函数依赖集F中每一个X->A,计算G=F-{X->A},再判断对于函数依赖集合G,是否能由X->A,如果能,在F中删除X->A。 3.对于F中每个函数依赖执行上述操作。 ...
  • 函数依赖: 字母表示:FD(Functional Dependency,FD) 定义:R(U),X、Y为属性,t1、t2为元组,若t1[X]=t2[X],则t1[Y]=t2[Y],称X函数决定Y函数或Y依赖于X,记作X→Y。 例3-22 对实例3-21“学生选课”关系...
  • 怎样求数据库最小函数依赖集

    千次阅读 2019-05-09 09:44:17
    设F是关系模式R(ABC)的FD,F={A->BC,B->C,A->B,AB->C},试求Fmin ** 步骤如下: ** ①先把F中的FD写成单属性模式 如题得到F={A->B,A->C,B->C,A->B,AB-C} 这里显然多了一个A->B可以删除...
  • 一、函数依赖 设R(U)是属性U上的关系模式,X,Y是U的子集,若对于R(U)上的任何一个可能的关系r,r中不肯呢过存在两个元组在X上的属性值相等,而在Y上的属性值不等,则称Y依赖于X,即X->Y.其中X成为决定属性组...
  • 用c++求数据库函数依赖集的闭包

    千次阅读 2016-05-24 17:49:48
    由于数据库作业要求用程序求一个函数依赖集中属性集的闭包和此依赖集的闭包,便用c++写了这个程序,刚好在这分享给大家,代码写得丑,望大家勿喷。
  • 数据库函数依赖闭包的求法

    万次阅读 多人点赞 2014-04-03 20:25:19
    定义:若F为关系模式R(U)的函数依赖集,我们把F以及所有被F逻辑蕴涵的函数依赖的集合称为F的闭包,记为F+。 即:F+={X→Y|X→Y∈F∨“应用Armstong公理从F中导出的任何X→Y”} △ F包含于F+,如果F=F+,则F为函数...
  • 文章目录一、函数依赖1. 函数依赖2. 完全函数依赖和部分函数依赖3. 传递函数依赖4. 与函数依赖相关的概念(1). 候选键(2). 主键(3). 主属性(4). 外来键(5). 逻辑蕴含(6). 闭包二、函数依赖的 Armstrong 公理及其引理1...
  • 如果函数依赖集F满足下列条件,则称F为一个极小函数依赖集,亦称为最小依赖集或最小覆盖(minimal cover)。 (1)F中任一函数依赖的右部仅含有一个属性 (2)F中不存在这样的函数依赖X->A,使得F与F-{X->A}...
  • 如果函数依赖集F满足下列3个条件,则称F为最小依赖集: (1)F中任一函数依赖的右部仅含有一个属性 (2)F中不存在这样的函数依赖X→A,使得F与F-{X→A}等价 (3)F中不存在这样的函数依赖X→A,X有真子集Z使得F-{X...
  • 数据库求闭包,最小函数依赖集

    万次阅读 多人点赞 2018-07-08 19:56:16
     例(1): 设有关系模式R(U,F),其中U={A,B,C,D,E,I},F={A→D,AB→E,BI→E,CD→I,E→C},计算(AE)+ 解: (1) 令X={AE},X(0)=AE (2)在F中寻找尚未使用过的左边是AE的子集的函数依赖,结果是: A→D, ...
  • 一、函数依赖:在关系R中,若属性或者属性 A 中 两个元祖的值相等,如果这两个元祖中对应的属性或者属性B中的值也相同,则记作A——>B。 A函数决定B; 或者 B函数依赖于A。例1:...
  • 定义:如果函数依赖集F满足下列条件,则称F为最小函数依赖集或最小覆盖。 ① F中的任何一个函数依赖的右部仅含有一个属性; ②F中不存在这样一个函数依赖X→A,使得F与F-fX→AJ等价; ③F中不存在这样一个函数依赖X...
  • 极小函数依赖集是求候选码、判断模式分解无损连接性和进行保持函数依赖性3NF求解常用的工具,了解此算法非常重要。 算法 假设:关系模式R<U,F>,其中U属性集,F为属性集上的函数依赖,求F的极小函数依赖集的...
  • 数据库求最小函数依赖集(最小覆盖)

    千次阅读 多人点赞 2020-03-03 21:57:11
    这个英文流程反而清晰,主要过程如下: 1.设置G=F; 2.右边属性单一化(这个很容易理解,网上的教学第一步都是这个),即对属性集中每一个X->(A1…An),将其拆为 X->A1,X->A2…,X->An ...
  • 最小函数依赖集的求解 一、定义  最小函数依赖集也称为极小函数依赖集、最小覆盖;如果函数依赖集F满足下列条件,则称F为一个最小依赖集。 F中任意函数依赖的右部仅含有一个属性 F中不存在这样的函数依赖X→A...
  • 一、函数依赖:在关系R中,若属性或者属性 A 中 两个元祖的值相等,如果这两个元祖中对应的属性或者属性B中的值也相同,则记作A——&gt;B。 A函数决定B; 或者 B函数依赖于A。例1:下表就是问题领域, 则存在...
  • 数据库老师布置的作业题目,求属性集闭包和函数依赖集闭包的算法实现 我用比较简单的方法算了一下 欢迎交流 import java.util.*; public class QiuBiBao_DBtext { public static void main(String[] ...
  • 关系数据库设计 函数依赖 逻辑蕴含

    千次阅读 多人点赞 2018-05-29 20:51:49
    F能推出 原不直观存在于 函数依赖集F 中的函数依赖 α →→\to β,则成α→→\toβ被函数依赖集F逻辑蕴含 函数依赖的闭包 F+F+F^+: ​ 由关系模式R直观得到的函数依赖F所推出的所有隐含的或未隐含的(直观...
  • 题目描述:已知关系R(A, B, C, D), 有函数依赖集F = { A->C; B->D; B,D->A }, 问{A,B}是不是R的候选键?
  • 1) 将函数依赖用multimap,string> 存储,因为函数依赖可能会有一对多,例如:A->X,A->Y;多重映射可以存储,一一映射只能能存储一对一。 2) 熟悉全排列组合的算法,即列出Cnk的所有可能结果(从Cn­­­1,Cn2,….,...
  • 数据库函数依赖

    千次阅读 热门讨论 2015-10-11 10:59:55
    一、函数依赖关系 1.数据依赖 数据依赖通常包括函数依赖和... 设一个关系R,X和Y是它的两个属性,若对于X上的每一个值都有Y上的一个唯一的值与之对应,则称X和Y 具有函数依赖关系,并称X函数决定Y,或称Y函数依赖
  • 最近在学数据库原理,关系规范化中介绍了几个算法,最基础也最重要的就是求属性X关于某个函数依赖集合F的闭包。 /*8周的功夫一本数据库基本原理就学完了,很快要考试了,所以5-1假期也没打算出去玩,就在学校了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 720
精华内容 288
关键字:

数据库函数依赖集