精华内容
下载资源
问答
  • 候选码:若关系中某一属性组的值能唯一地标识一个元组,而其子集不能,则称该属性组为候选码 主码:若一个关系中有多个候选码,则选定其中一个为主码 主属性:候选码的诸属性为主属性 比方说选修(学号,课程号,...

    这是一个初学者很容易绕晕的知识点,这里我用图文的形式让他们更加形象化

    候选码:若关系中某一属性组的值能唯一地标识一个元组,而其子集不能,则称该属性组为候选码

    主码:若一个关系中有多个候选码,则选定其中一个为主码

    主属性:候选码的诸属性为主属性

    比方说选修(学号,课程号,成绩)
    候选码就可以是:学号、课程号、学号和课程号,而主码就是选定其中一个,而主属性就是这三个候选码的属性
    那么通过这个例子我们就可以大致归纳出主码和主属性的关系:

    在这里插入图片描述

    典例二、若属性X函数依赖于属性Y时,则属性X与属性Y之间具有( )

    A.一对一联系 B.一对多联系
    C.多对一联系 D.多对多联系

    解析:一般讨论的都是非平凡的函数依赖(X —> Y,但Y不属于X),X —> Y为1对多,而根据该题可知Y —> X,所以X与Y是多对一
    故选C

    之后我会持续更新,如果喜欢我的文章,请记得一键三连哦,点赞关注收藏,你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 !!!↖(▔▽▔)↗感谢支持!

    展开全文
  • 函数依赖的闭包 属性集闭包 码 求候选键算法 最小函数依赖集 关系模式R(U,D,DOM,F) R:关系名,符号化的元组定义 U:一组属性 D:属性组U中的属性所来自的域 DOM:属性到域的映射 F:属性组U上的一组数据...

    目录

    关系模式

    函数依赖的闭包

    属性集闭包

    求候选键算法

    最小函数依赖集


    关系模式R(U,D,DOM,F)

    R:关系名,符号化的元组定义

    U:一组属性

    D:属性组U中的属性所来自的域

    DOM:属性到域的映射

    F:属性组U上的一组数据依赖

    函数依赖集的闭包

    F:FD(Functional Dependency)的集合称为函数依赖集。

    F闭包:由F中的所有FD可以推导出所有FD的集合,记为F+。

     

    例1,对于关系模式R(ABC),F={A→B,B→C},求F+。

    根据FD的定义,可推出F+={φ→φ,A→φ,A→A,A→B,A→C,A→AB,A→BC,A→ABC,…},共有43个FD。其中,φ表示空属性集。

     

    属性集闭包

    属性集闭包定义 :
    对F,F+中所有X→A的A的集合称为X的闭包,记为X+。可以理解为X+表示所有X可以决定的属性。

    属性集闭包的算法:

    A+:将A置入A+。对每一FD,若左部属于A+,则将右部置入A+,一直重复至A+不能扩大。

     

    设K为R(U,F)中的属性或属性集合,

    候选码:若U对K完全函数依赖。则K为R的候选码。

    超码:若U对K部分函数依赖。则K为R的超码,候选码是最小的超码。若候选码多余一个,则选择一个作为主码

     设关系模式R中U=ABC.......等N个属性,U中的属性在FD中有四种范围:

    (1)左右出现;

    (2)只在左部出现;

    (3)只在右部出现;

    (4)不在左右出现;

     

     求候选键算法:

    1.R:只在FD右部出现的属性,不属于候选码;

    2.L:只在FD左部出现的属性,一定存在于某候选码当中;

    3.N:外部属性一定存在于任何候选码当中;

    4.其他属性逐个与2,3的属性组合,求属性闭包,直至X的闭包等于U,若等于U,则X为候选码。

    例2,对于关系模式R(ABCD),F={A→B,B→C,D→B},求其候选键。

    先按照属性集闭包的算法,求各个闭包,然后求得候选键。

    (1)      求A+。 

    ①       A+=A。 
    ②       由A→B,而A €A+可知,则A+=AB。

    ③       由B→C,而B  A+可知,则A+=ABC。

    ④       A+封闭,即A+=ABC。

    (2) 求B+、C+、D+。 

    按步骤(1)可得:B+=BC,C+=C,D+=BCD。

    (3) 求其候选键。 显然,R的候选键为AD。

    例3,对于关系模式R(ABC),F={A→BC,BC→A},求其候选键。

    (1)   求属性的闭包。 
    按例2可得:A+=ABC,B+=B,C+=C。 

    (2)    求属性集的闭包。 
    由BC→A,则(BC)+=ABC,其余属性集闭包为属性闭包的并集。

    (3)   求其候选键。 显然,R的候选键为A和BC。

     

    最小函数依赖集

    定义:如果函数依赖集F满足以下条件,则称F为一个极小函数依赖集。也称为最小依赖集或最小覆盖。

    (1)F中任一函数依赖的右部仅含有一个属性。

    (2)F中不存在这样的函数依赖X→A,使得F与F-{X→A}等价。

    (3)F中不存在这样的函数依赖X→A,X有真子集Z使得F-{X→A}U{Z→A}与F等价。

    最小依赖集通用算法:

    ① 用分解的法则,使F中的任何一个函数依赖的右部仅含有一个属性;

    去掉多余的函数依赖:从第一个函数依赖X→Y开始将其从F中去掉,然后在剩下的函数依赖中求X的闭包X+,看X+是否包含Y,若是,则去掉X→Y;否则不能去掉,依次做下去。直到找不到冗余的函数依赖;

    ③ 去掉各依赖左部多余的属性。一个一个地检查函数依赖左部非单个属性的依赖。例如XY→A,若要判Y为多余的,则以X→A代替XY→A是否等价?若A属于(X)+,则Y是多余属性,可以去掉。

    例4、求F={A→B,B→A,B→C,A→C,C→A},最小(极小)函数依赖集合

    1、利用分解规则,将所有的函数依赖变成右边都是单个属性的函数依赖。从题目来看,F中的任何一个函数依赖的右部仅含有一个属性:
    {A→B,B→A,B→C,A→C,C→A}

    2、去掉F中多余的函数依赖

    (1)设A→B冗余,从F中去掉A→B,则F1={B→A,B→C,A→C,C→A}。计算(A)F1+:设X(0)=A,计算X(1):扫描F1中各个函数依赖,找到左部为A或A子集的函数依赖,A→C。故有X(1)=X(0)U C=AC;扫描F1中各个函数依赖,找到左部为AC或为AC子集的函数依赖,C→A,X(2)=X(1)U C=AC.但AC不包含B,故A->B不能从F中去掉。

    (2)设B→A冗余,从F中去掉B→A,则F2={A→B,B→C,A→C,C→A}。计算(B)F2+:设X(0)=B,计算X(1):扫描F2中各个函数依赖,找到左部为B或者B子集的函数依赖,B→C.故有X(1)=X(0)U C =BC;扫描F2中各个函数依赖,找到左部为BC或为BC子集的函数依赖,C->A,X(2)=X(1)U A=ABC.X(2)包含所有属性,故B→A可从F中去掉。

    (3)设B→C冗余,从F中去掉B→C,则F3={A→B,A→C,C→A}。计算(B)F3+:扫描F3中各个函数依赖,找不到左部为B或B子集的函数依赖,因为找不到这样的函数依赖,故有X(1)=X(0)=B,(B)F1+= B不包含C,故B→C不是冗余的函数依赖,不能从F1中去掉。

    (4)设A→C冗余,从F中去掉A→C,则F4={A→B,B→C,C→A}。计算(A)F4+:设X(0)=A,计算X(1):扫描F4中各个函数依赖,找到左部为A或A子集的函数依赖,A→B。故有X(1)=X(0)U B=AB;扫描F4中各个函数依赖,找到左部为AB或为AB子集的函数依赖,B→C,X(2)=X(1)U C=ABC.X(2)包含所有属性,故A→C可从F中去掉。

    (5)设C→A冗余,从F中去掉C→A,则F4={A→B,B→C}。计算(C)F5+:设X(0)=C,计算X(1):扫描F5中各个函数依赖,找到左部为C或C子集的函数依赖,找不到左部为C或C子集的函数依赖,因为找不到这样的函数依赖,故有X(1)=X(0)=C,(B)F1+= C不包含A,故C→A不是冗余的函数依赖,不能从F中去掉。

    (6)至此,所有依赖均以验算完毕,故F最小(极小)函数依赖集合为:{A→B,B→C,C→A}

      转载自原文作者:itwolf

    展开全文
  • 函数依赖X→YX→YX\rightarrow Y表示X的值确定,Y的值也是确定的,表现在数据库上就是X和Y都是属性集的子集,也就可以看成投影出的两张表,如果X[i]=X[j]即X中某两行相等,那么Y[i]=Y[j]即相应的Y的这两行也一定...

    这几天数据库听的有点混乱,整理一下。

    函数依赖(FD)

    函数依赖 XY X → Y 表示当X的值确定时,Y的值也是确定的,表现在数据库上就是X和Y都是属性集的子集,也就可以看成投影出的两张表,如果X[i]=X[j]即X中某两行相等,那么Y[i]=Y[j]即相应的Y的这两行也一定相等。或者说,如果大表中的某两行在X上的值相等,那么在Y上的值也相等,也即Y的取值依赖于X的取值(但不表示知道X就知道Y,因为仅仅是说X相等时Y也一定相等)。

    平凡和非平凡的FD

    对于函数依赖 XY X → Y ,如果 YX Y ⊆ X ,那么称 XY X → Y 是一个平凡的函数依赖,否则称为非平凡的函数依赖。

    FD集的逻辑蕴涵

    蕴涵 PQ P ⇒ Q 在离散数学中就是当P的取值为真时,Q的取值也一定为真。放在函数依赖(FD)上,FD 的逻辑蕴涵指就是知道某函数依赖为真,可以推出某(不见得是”另一个”)函数依赖为真。

    函数依赖集F逻辑蕴涵X->Y记为 FXY F ⊨ X → Y

    FD集的闭包

    函数依赖的闭包是被F所逻辑蕴涵的所有函数依赖组成的函数依赖集,函数依赖集F的闭包记为 F+={XY|FXY} F + = { X → Y | F ⊨ X → Y }

    属性集在FD集上的闭包

    属性集X在函数依赖集F上的闭包记作 X+F={A|XAF+} X F + = { A | X → A ∈ F + } ,是指从F能够直接或者间接推出的所有形如 XA X → A 的函数依赖中的属性A的集合。

    XY X → Y 能用FD推理规则推出的充分必要条件是 YX+F Y ⊆ X F +

    计算 X+F X F + 就是将初始只有X的集合 X(i) X ( i ) 每次不断并上 {A|YZFAZYX(i)} { A | Y → Z ∈ F ∧ A ⊆ Z ∧ Y ⊆ X ( i ) } ,作为新的 X(i) X ( i ) 直到它不再变化。

    FD集的等价

    如果两个FD集合的闭包相同即 F+=G+ F + = G + ,它们就是等价的。

    FD集的最小依赖集

    任何一个FD集都至少存在一个最小的等价FD集 Fmin F m i n ,即称为它的最小依赖集。要求 Fmin F m i n 里每个FD的左右都没有多余的属性,并且也没有多余(能被其它FD推出)的FD。

    求最小依赖的过程:

    ①消除右端多余属性

    直接将右端拆开成单属性(分解规则)。

    ②消除左端多余属性

    使用伪传递性 XY,YWZ X → Y , Y W → Z XWZ X W → Z 的变形消除左边多余的那部分。

    例如 BD B → D BDC B D → C 能将 BDC B D → C 消除多余的D而变成 BC B → C

    ③消除多余的FD

    使用传递性,来自传递可得的FD直接被消除。

    展开全文
  • 最近在学数据库原理,关系规范化中介绍了几个算法,最基础也最重要的就是求属性集X关于某个函数依赖集合F的闭包。 /*8周的功夫一本数据库基本原理就学完了,很快要考试了,所以5-1假期也没打算出去玩,就在学校了...

    最近在学数据库原理,关系规范化中介绍了几个算法,最基础也最重要的就是求属性集X关于某个函数依赖集合F的闭包。

    /*8周的功夫一本数据库基本原理就学完了,很快要考试了,所以5-1假期也没打算出去玩,就在学校了复习、休息等等。就在复习的过程中,突然发现书上对于函数依赖集合的闭包,以及属性集合的闭包的区别,几乎没有介绍。我看了好几遍才看懂,所以特此补充,以便同我有相同疑问的朋友理解。*/

    /*这是在2016年五一劳动节修改的,哈哈,我是中国好程序员,劳动节就劳动得度过[]~( ̄▽ ̄)~*。之前求闭包没有采用递归的方式,过程十分繁琐,不值得推荐,所以删去的之前的那段代码。采用递归,更加贴近定义,思路更加清晰。此外,精简优化了一下代码,删除了一些不必要的函数,或者转换更好的思路,代码量得到了精简。*/


    首先说一下,函数依赖集的闭包

    ----------------------------------------------------分割线-------------------------------------------------------------------------------------------

    函数依赖的闭包 

    定义:若F为关系模式R(U)的函数依赖集,我们把F以及所有被F逻辑蕴涵的函数依赖的集合称为F的闭包,记为F+。

    什么是“被F逻辑蕴涵"呢?


    函数依赖的逻辑蕴涵:

    定义:设有关系模式R(U)及其函数依赖集F,如果对于R的任一个满足F的关系r函数依赖X→Y都成立,则称F逻辑蕴涵X→Y,或称X→Y可以由F推出。

    例:关系模式 R=(A,B,C),函数依赖集F={A→B,B→C}, F逻辑蕴涵A→C


    所以说:函数依赖集F的闭包,里面的元素还是函数依赖(就是X→Y这种东西),函数依赖集F的闭包包括F自身,加上能从F中通过Armstong公理推导出的,新的函数依赖。 

    即:F+={X→Y|X→Y∈F∨“应用Armstong公理从F中导出的任何X→Y”}


    为了判断函数依赖X->Y是否在F+中,只要计算出F+即可。因为F+是由F根据Armstrong公理导出的函数依赖的集合。因此,原则上说,只要按照Armstrong公理系统中的推理规则就可以计算出F+。但是,闭包F+的计算是一件很麻烦的事情,因为计算F+的问题是一个NP完全问题,即若F={X->A1, X->A2, …, X->An,},则需要计算F+的O(2n)个函数依赖,因此,当 n比较大时,实际计算F+是不可行的。即使F的元素不多时, F+中的元素也可能很多。此外,闭包F+中也存在许多冗余信息。其实,判断一个函数依赖X->Y是否在F+中,完全不必计算闭包F+


    一个重要的定理:X->Y属于F+,等价于Y属于X关于F的闭包。X,Y都是F中的属性。


    那什么是属性X关于F的闭包呢?

    ----------------------------------------------------分割线-------------------------------------------------------------------------------------------

    2.属性集X(X∈U)对于U上的一个函数依赖集F的闭包X_F^+

    (1)定义: 设关系模式R(U,F ),U 为其属性集,F 为其函数依赖集,则称在所有用Armstrong 公理从F 推出的函数依赖X → Ai 中,Ai 的属性集合为X 的属性闭包。

    也就是说,属性集X关于函数依赖集合的闭包,里面的元素是属性(而不是函数依赖),这些属性是F根据Armstrong 公理推导出来的。


    好吧为了充分理解,补充一下什么是Armstrong 公理:

    Armstrong公理 
     1、定理:若U为关系模式R的属性全集,F为U上的一组函数依赖,设X、Y、Z、W均为R的子集,对R(U,F)有:
            F1(自反性):若X≥Y(表X包含Y),则X→Y为F所蕴涵;(F1':X→X)
            F2(增广性): 若X→Y为F所蕴涵,则XZ→YZ为F所蕴涵;(F2':XZ→Y)
            F3(传递性): 若X→Y,Y→Z为F所蕴涵,则X→Z为F所蕴涵;
            F4(伪增性):若X→Y,W≥Z(表W包含Z)为F所蕴涵,则XW→YZ为F所蕴涵;
            F5(伪传性): 若X→Y,YW→Z为F所蕴涵, 则XW→Z为F所蕴涵;
            F6(合成性): 若X→Y,X→Z为F所蕴涵,则X→YZ为F所蕴涵;
            F7(分解性): 若X→Y,Z≤Y (表Z包含于Y)为F所蕴涵,则X→Z为F所蕴涵。
            函数依赖推理规则F1∽F7都是正确的。
     2、Armstrong公理:
    推理规则F1、F2、F3合称Armstrong公理;
    F4 ∽ F7可由F1、F2、F3推得,是Armstrong公理的推论部分。
    

    (2)计算: 求属性集X 关于函数依赖F 的属性闭包X+。设关系模式R 的全部属性集为U,在U 上的函数依赖集为F,U 的一个子集为X,计算X 关于F 的属性闭包X+ 。

    具体方法如下:

    ①置初始X(0)= Ф,X(1)=X;

    ②如果X(0)≠ X(1),置X(0)=X(1),否则转④;

    ③对F 中的每一个函数依赖Y → Z,若Y X(1),置X(1)=X(1)∪ Z,转②;

    ④结束,即X(1)为X+。

    下面我们借助一个例子来说明属性闭包的计算过程。

    例1: 设有关系模式R(U,F),其中U={A,B,C,D,E},F={ AB → C,B → D,C → E,CE → B,AC → B},计算(AB)+。

    解: 由上述算法得:

    第一次: ① X(0)= Ф,X(1)=AB;

    ②由于X(0)≠ AB,置X(0)=AB;

    ③搜索F中的每一个函数依赖,得AB →C与B→D为AB,B X(1),置X(1)=AB ∪ C ∪ D=ABCD;

    第二次: ② X(0)≠ ABCD,则X(0)=ABCD;

    ③找到C → E 与AC → B,置X(1)=ABCD ∪ E ∪ B=ABCDE;

    第三次: ② X(0)≠ ABCDE,则X(0)=ABCDE;

    ③找到CE → B,置X(1)=ABCDE ∪ B=ABCDE;

    第四次: ② X(0)=X(1),转④;

    ④结束,即X(1)=(AB)+=ABCDE。


    为了简便,将各个属性用字符表示,程序如下:


    //求属性集X(X∈U)对于U上的一个函数依赖集F的闭包X_F^+
    //输入:属性全集U,U上的函数依赖F,属性集X (X∈U)
    //输出:X关于F的闭包 X_F^+
    #include <iostream>
    #include <string>
    using namespace std;
    
    struct FunctionDependence//函数依赖 
    {
    	string X;//决定因素 
    	string Y;	
    };
    
    void Init (FunctionDependence FD[],int n)
    {
    	//函数依赖关系初始化
    	int i;
    	string x,y;
    	cout<<"请输入F中的函数依赖(决定因素在左,被决定因素在右)"<<endl; 
    	//输入函数依赖集合F 
    	for (i=0;i<n;i++)
    	{		
    		cin>>x>>y;
    		FD[i].X=x;
    		FD[i].Y=y;	
    	} 
    	cout<<"函数依赖集合F:"; 
    	cout<<"F={" ;
    	for (i=0;i<n;i++)
    	{
    		//显示已知的函数依赖集合F 
    
    		cout<<FD[i].X<<"->"<<FD[i].Y;
    		if (i<n-1)cout<<", ";	
    	} 
    	cout<<"}"<<endl; 
    }
    
    bool IsIn(string f,string zz)//能够判断F中决定因素f里所有的因素是否在X中,但这样可能导致结果出现重复 
    {
    	bool flag1=false;
    	int len1=f.length();
    	int len2=zz.length();
    	int k=0,t=0,count1=0;
    	for (k=0;k<len1;k++)
    	{
    		for (t=0;t<len2;t++)
    		{
    			if (f[k]==zz[t])
    			{
    				//flag1=true;break;
    				count1++;
    			}
    		}
    	}
    	if (count1==len1)
    	{
    		flag1=true;
    	}
    	else flag1=false;
    	return flag1;
    }
    string CutAndSort(string mm)//将最终得到的闭包去除其中重复的元素,并且进行排序 
    {
    	
    	int size=mm.length();
    	int kk=0,ii=0;;
    	string closure;
    	int a[200]={0};//用来记录各个命题出现的次数
    	for(kk=0;kk<size;kk++) 
    	{
    		a[(int)mm[kk]]++;//强制转换类型,储存各个因素的次数 
    	}
    	 
    	for (ii=0;ii<200;ii++)
    	{
    		if (a[ii]>=1)//cout<<(char)ii;
    		closure+=(char)ii;
    	} 
    	return 	closure;
    } 
    
    string X_Fn(FunctionDependence FD[],int n,string &xx)
    {
    	string yy=xx;
    	for (int i=0;i<n;i++)
    	{
    		if (IsIn(FD[i].X,yy)==true)
    		{
    			xx+=FD[i].Y;
    		}		
    	}
    	yy=CutAndSort(yy);
    	xx=CutAndSort(xx);	
    	//cout<<"yy="<<yy;
    	//cout<<"        xx="<<xx<<endl;
    	if (xx!=yy)
    	{
    		X_Fn(FD,n,xx);//递归 
    	}
    	return xx; 
    }
    
    void FD(FunctionDependence FD[],int n)
    {
    	//输入 X
    	string xx;
    	int i;
    
    	cout<<"\n请输入属性集X:"; 
    	cin>> xx;
    	cout<<"\n"<<xx<<"关于F的闭包:{";
    	//求X关于F的闭包
    	cout<<X_Fn(FD,n,xx);
    	
    	cout<<"}\n";
    }
    
    int main()
    {
    	int N;
    	cout<<"请输入F中函数依赖的组数:"; 
    	cin>>N;
    	
    	FunctionDependence fd[N];
    	Init(fd,N);	
    	FD(fd,N);
    	FD(fd,N);
    	FD(fd,N);
    	 
    	return 0;
    } 






    展开全文
  • 关系数据库设计 函数依赖 逻辑蕴含

    千次阅读 多人点赞 2018-05-29 20:51:49
    F能推出 原不直观存在 函数依赖集F 中的函数依赖 α →→\to β,则成α→→\toβ被函数依赖集F逻辑蕴含 函数依赖的闭包 F+F+F^+: ​ 由关系模式R直观得到的函数依赖F所推出的所有隐含的或未隐含的(直观...
  • 数据库函数依赖名词的解释

    千次阅读 2020-06-18 15:17:06
    假设有AB两个函数,ABA 决定 B,即A推出B,也叫做B函数依赖于A) 平凡函数依赖:当属性集Y是属性集X的子集,必然存在函数依赖X→Y,这种类型称为平凡的函数依赖 有函数ABBA的子集(即B里面的内容...
  • 或者 B函数依赖于A。例1:下表就是问题领域, 则存在的函数依赖有哪些呢?属性A的值都不相等,所以A---&gt;B; 而属性B中前两行元祖相同,对应的属性C的前两组元祖也相同,所以B-----&gt;C;而属性C的三行...
  • 【数据库之函数依赖

    千次阅读 热门讨论 2015-10-11 10:59:55
    一、函数依赖关系 1.数据依赖 数据依赖通常包括函数依赖和... 设一个关系R,X和Y是它的两个属性集,若对于X上的每一个值都有Y上的一个唯一的值与之对应,则称X和Y 具有函数依赖关系,并称X函数决定Y,或称Y函数依赖
  • 函数依赖里面,函数依赖公理,Armstrong公理以及属性闭包的定义都有必要仔细学习 1.逻辑蕴含基本定义 2.Armstrong公理和推论–可以用来判断一个函数依赖X -&gt; Y 是否逻辑蕴含于函数依赖集F Armstrong推论...
  • [模式]函数依赖

    千次阅读 2014-11-19 10:35:30
    函数依赖简单地说就是属性A推导出属性B,比如给定这些规则之后,如果某个关系能够满足给定的函数依赖,则称关系R满足函数依赖F; 在下面我们会介绍一系列的范式以及分解算法; 函数依赖的分解合并规则 与 是...
  • 函数依赖和范式

    千次阅读 2018-12-13 18:25:29
    1、函数依赖概念:相当于数学中的函数,U是属性全集,x和y是U上的子集,x对应唯一确定的y,即x-&gt;y(y依赖于x)。 2、完全依赖和不完全依赖:U是属性全集,x和y是U上的子集,x1是x的真子集,如果x-&gt;y...
  • 函数依赖、多值依赖

    千次阅读 2019-03-13 09:49:12
    设R(U)是属性U上的一个关系模式,X和Y均为U={A1,A2,…,An}的子集,r为R的任一关系,如果对于r中的任意两个元组u,v,只要有u[X]=v[X],就有u[Y]=v[Y],则称X函数决定Y,或称Y函数依赖于X,记为X...
  • B 表示 A 函数决定 B,也可以说 B 函数依赖于 A。 如果 {A1,A2,... ,An} 是关系的一个或多个属性的集合,该集合函数决定了关系的其它所有属性并且是最小的,那么该集合就称为键码。 对于 A->B,如果能找到 A...
  • 根据函数依赖求候选码

    千次阅读 多人点赞 2019-06-26 11:37:39
    算法:按以下步骤求候选键: 1.只在FD右部出现的属性,不属于候选码; 2.只在FD左部出现的属性,一定存在某候选码当中; 3.外部属性一定存在任何候选码...,U=(A,B,C,D,E,G),F={AB-->C,CD-->E,E-->A.A--&g...
  • 函数依赖的逻辑蕴涵

    千次阅读 2018-07-13 11:44:13
    函数依赖的逻辑蕴涵(转)一、逻辑蕴涵 定义:设有... 例:关系模式 R=(A,B,C),函数依赖集F={AB,B→C}, F逻辑蕴涵A→C。证:设u,v为r中任意两个元组: 若A→C不成立,则有u[A]=v[A],而u[C]≠v[C] 而且AB,...
  • 数据库关系模式的函数依赖习题讲解

    万次阅读 多人点赞 2020-05-15 16:45:10
    设有关系模式 R(职工名,项目名,工资,部门名,部门经理) 如果规定,每个职工可参加多个项目,各领一份工资;每个项目只属于一个部门管理;...>设有关系模式R(AB,C,D,E),其函数依赖集为F={AB,C
  • 数据库之函数依赖

    千次阅读 多人点赞 2018-08-23 14:34:26
    今天又重新拾起了《数据库系统原理》,因为之前对它学的不够扎实,所以现在需要重新进行深入的学习,函数依赖这一部分虽然不是特别难,但是我就是有点“迷”,老是有点弄不清楚,所以今天抽出点时间“收拾”他一下,...
  • 平凡函数依赖与非平凡函数依赖 完全函数依赖与部分函数依赖 传递函数依赖 确定函数依赖的方法 码 外部码 范式 1NF 2NF 3NF BCNF 多值依赖 4NF 如何判断R为第几范式? 已知一个关系模式的属性之间的...
  • 数据库基础1—函数依赖 多值依赖

    万次阅读 2014-09-16 13:47:53
    在数据库知识中有讲到数据库的函数依赖
  • 函数依赖和关系模式分解

    千次阅读 2020-06-23 10:11:40
    文章目录一,第一范式关系数据库设计中易犯的错误数据冗余插入、删除、修改异常模式分解函数依赖(FD)函数依赖的使用函数依赖集的闭包Armstrong 公理计算 F^+^属性集的闭包属性闭包的用途正则覆盖无关属性检测属性...
  • 通过A得到B,通过B得到C,但是C得不到BB得不到A,那么说C传递依赖于A。 –举例说明: Student表:Sno(学号),Sdept(系),Mname(系主任名字),Cno(课程号),Grade(成绩) ex1: (Sno,Cno)-&g
  • 【数据库复习】函数依赖

    万次阅读 多人点赞 2012-04-27 21:03:16
    函数依赖简单地说就是属性A推导出属性B,比如 给定这些规则之后,如果某个关系能够满足给定的函数依赖,则称关系R满足函数依赖F;   在下面我们会介绍一系列的范式以及分解算法;   函数依赖的分解合并...
  • 数据库求闭包,最小函数依赖

    万次阅读 多人点赞 2018-07-08 19:56:16
     例(1): 设有关系模式R(U,F),其中U={AB,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, ...
  • 一个是最小依赖函数集,一个是求候选码,一个是求闭包,一个是要把关系模式分解成3NF且保持函数依赖,一个是分解成3NF且保持函数依赖和无损连接。 记录一下我对这几个问题的求法。可能会有哪里有漏洞,希望可以指...
  • 函数依赖(FD)

    万次阅读 2006-05-14 20:09:00
    1、函数依赖的定义(领会):设有关系模式R(A1,A2,...An)或简记为R(U),X,Y是U的子集,r是 R的任一具体关系,如果对r的任意两个元组t1,t2,由t1[X]=t2[X]导致t1[Y]=t2[Y],则称X函数决 定Y,或Y函数依赖于X,记为X→...
  • (13)函数依赖的推理规则(armstrong公理)

    千次阅读 多人点赞 2019-06-28 17:33:49
    目录 问题引入: 1.逻辑蕴涵 2.Armstrong公理系统 3.函数依赖的闭包 ...② 给定一组函数依赖,是否能导出另外一些函数依赖,或另外的函数依赖是否成立。 如FD={A ->BB ->C},A ->...
  • 函数依赖、键和范式

    千次阅读 2017-02-27 19:51:06
    1.函数依赖 X→Y,表示Y依赖于X; X→Y,且Y→X不成立,Y→Z,则X→Z,表示Z传递依赖于X。 2.键 3.图解法求候选键 4.范式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 189,073
精华内容 75,629
关键字:

当b属性函数依赖于a属性时