本文介绍了一种用于判断关系数据库模式分解是否为无损联接分解的方法，并通过实例详细展示了具体的判定步骤。
定义：无损联接分解是将一个关系模式分解成若干个关系模式后，通过自然联接和投影等运算仍能还原到原来的关系模式，则称这种分解为无损联接分解。
无损分解的判定算法
输入：一个关系模式R（A1，A2，A3，...,An）,R上的一个函数依赖集合F以及一个分解p{{R1,F1},{R2,F2},...,{Rk,Fk]}
输出：确定p是否是一个连接不失真分解
方法：
（1）建立建立用来检验连接是否失真的kxn表
| A1 | A2 | ... | Aj | |
| R1 | ||||
| R2 | ||||
| ... | ||||
| Rk |
（2）填表：若Aj属于Ri,则将第i行第j列填为aj,否则填入bij。
（3）修改表：逐一考察F中的函数依赖X->Y，X可能包含一个或者多个属性，如果这（个）些属性对应于表中的列的值相同，则值相等的行所对应的Y属性所有的列的值也相等。（比方说X->Y，X是A1A2所对应的属性，Y是属性A4。由第一步，如果表中第一行和第二行的值相等，那么表中A4对应的第一行和第二行的值也要修改成一样的。）如果其中有aj,则将bij改成aj;如果没有aj，就将他们都改成bij,一般来说i是值相等的行中最小的行号。
（4）反复（指在前一次修改地基础上，反复进行，直到表中的数据不再改变）进行（3），若发现某一行变成a1,a2,...,aj,则可以得出分解p{{R1,F1},{R2,F2},...,{Rk,Fk]}具有连接不失真性。
设R=ABCDE, R1=AD,R2=BC,R3=BE,R4=CDE, R5=AE, 设函数依赖：
A->C, B->C, C->D, DE->C, CE->A. 判断R分解成
ρ={R1, R2, R3, R4, R5}是否无损联接分解？
解：
这样的题要通过画表的方法来解，首先，原始表：
|
|
A
|
B
|
C
|
D
|
E
|
|
AD
|
a1
|
b
12
|
b
13
|
a4
|
b
15
|
|
BC
|
b
21
|
a2
|
a3
|
b
24
|
b
25
|
|
BE
|
b
31
|
a2
|
b
33
|
b
34
|
a5
|
|
CDE
|
b
41
|
b
42
|
a3
|
a4
|
a5
|
|
AE
|
a1
|
b
52
|
b
53
|
b
54
|
a5
|
表1
(A B C D E
是关系R
的属性， AD, BC, BE, CDE, AE
是分解之后每一个关系对应的属性集)
填表的过程：
当横竖相交的时候，如果在分解关系中存在对应列的单个的属性（譬如第一列第一行AD与A相交的单元格，AD含有A，就填写a1），则填写a
下标
， 下标就是单元格对应所在的列号。否则填写b下标， 下标是单元格对应所在的行列号。
填写之后的初始表就是表1
所示
2.根据依赖关系修改原始表：
对于依赖关系A->C，看A列中有两行a1是相等的（第一行和第五行），所以在C列中对应的两行也应该相等，但是看到这两行都是b（b13，b53），所以将这个b都换成b13（上面的较小的标）
|
|
A
|
B
|
C
|
D
|
E
|
|
AD
|
a1
|
b
12
|
b13
|
a4
|
b
15
|
|
BC
|
b
21
|
a2
|
a3
|
b
24
|
b
25
|
|
BE
|
b
31
|
a2
|
b
33
|
b
34
|
a5
|
|
CDE
|
b
41
|
b
42
|
a3
|
a4
|
a5
|
|
AE
|
a1
|
b
52
|
b53
à
b13
|
b
54
|
a5
|
对于依赖BàC, 同样的道理，看B这一列中，第二行和第三行都是a2,那么对C这一列同样的操作，但是看到C这一列中第二行是a3，那么就将第三行改成a3，优先级比b要高。
|
|
A
|
B
|
C
|
D
|
E
|
|
AD
|
a1
|
b
12
|
b
13
|
a4
|
b
15
|
|
BC
|
b
21
|
a2
|
a3
|
b
24
|
b
25
|
|
BE
|
b
31
|
a2
|
b33àa
3
|
b
34
|
a5
|
|
CDE
|
b
41
|
b
42
|
a3
|
a4
|
a5
|
|
AE
|
a1
|
b
52
|
b
13
|
b
54
|
a5
|
对依赖CàD，C列的1，5行相等，D的1，5行也应该相等，D的第1行有a，所以b54换成a4；另外C列的2，3，4行也相等，D的2，3，4行也应该相等，D的第4行有a，所以将对应的行都换成a4
|
|
A
|
B
|
C
|
D
|
E
|
|
AD
|
a1
|
b
12
|
b
13
|
a4
|
b
15
|
|
BC
|
b
21
|
a2
|
a3
|
b24àa
4
|
b
25
|
|
BE
|
b
31
|
a2
|
a3
|
b34àa
4
|
a5
|
|
CDE
|
b
41
|
b
42
|
a3
|
a4
|
a5
|
|
AE
|
a1
|
b
52
|
b
13
|
b54àa
4
|
a5
|
对于DEàC, DE公共的相等的行是3，4，5行，对应C的3，4，5行也应该相等，故将C列的两个的b13换成a3，所以表格经过这个函数依赖关系，就是：
|
|
A
|
B
|
C
|
D
|
E
|
|
AD
|
a1
|
b
12
|
b13àa
3
|
a4
|
b
15
|
|
BC
|
b
21
|
a2
|
a3
|
a4
|
b
25
|
|
BE
|
b
31
|
a2
|
a3
|
a4
|
a5
|
|
CDE
|
b
41
|
b
42
|
a3
|
a4
|
a5
|
|
AE
|
a1
|
b
52
|
b13àa
3
|
a4
|
a5
|
对于CEàA, CE的公共行是3，4，5行，所以将A的3，4，5行也对应相等，因为A列的第五行含有a1，所以将3，4行的b31,b41都换成a1
最终得到的表格就是：
最后，我们从表格里看到对于DE行来说，都是a，所以得出结论，题中的分解是无损联接分解
********************
程序：
//数据库编程实验
//分解的无损连接判断
//输入：关系模式R(A1，A2，A3，...,An)
//R上的函数依赖集F以及R的一个分解 p={{R1,F1},{R2,F2},...,{Rk,Fk}}
//输出：用来检验连接是否失真的nxk表，以及是否连接无损的判断
#include <iostream>
#include <string>
//#include <stdlib.h>
using namespace std;
struct T
{
char word;//表中的标记字符a or b
int row;//行标
int col;//列标
};
struct FunctionDependence//函数依赖
{
string X;//决定因素
string Y;
};
void InitFD(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<<"函数依赖集合";
cout<<"F={" ;
for (i=0;i<n;i++)
{
//显示已知的函数依赖集合F
cout<<FD[i].X<<"->"<<FD[i].Y;
if (i<n-1)cout<<", ";
}
cout<<"}"<<endl;
}
bool T_equal(T t1,T t2)//比较两个表中的值是否完全相等
{
bool f=false;
if (t1.word==t2.word)
{
if (t1.row==t2.row)
{
if (t1.col==t1.col)
{
f=true;
}
}
}
return f;
}
bool IsIn(string f, string zz)
{
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;
}
bool CharIsIn(char f, string zz)
{
bool flag = false;
int len = zz.length();
int k = 0, count1 = 0;
for (k = 0;k<len;k++)
{
if (f == zz[k])
{
flag= true;;
}
}
return flag;
}
void show(string A,int lengthR)
{
for (int i=0;i<=lengthR;i++)
{
cout<<"--------";
}
cout << "\n\t";
for (int i = 0;i<lengthR;i++)
{
cout <<A[i] << "\t";
}
cout<<endl;
for (int i=0;i<=lengthR;i++)
{
cout<<"--------";
}
cout << endl;
}
int main()
{
//第零步：初始化
cout<<"请输入关系模式R（中间无间隔，无回车）"<<endl;
string A;
cin >> A;
int lengthR = A.length();
cout<<"关系模式R={";
for (int i = 0;i<lengthR;i++)
{
cout << A[i] ;
if (i<lengthR-1)cout<<",";
}
cout<<"}"<<endl;
int count = 0;
string R[lengthR+20];
cout<<"输入R的一个分解p(以0结束)\n";
while (cin >> R[count])//当输入的字符串不在R中时自动跳出
{
if (IsIn(R[count],A) == false) break;
count++;
}
cout<<"p={";
for (int i = 0;i<count;i++)
{
cout << R[i] ;
if (i<count-1)cout<<",";
}
cout<<"}";
int N;
cout<<"\n请输入F中函数依赖的组数:";
cin>>N;
FunctionDependence fd[N];
InitFD(fd,N);
//第一步：建立用来检验连接是否失真的nxk表,实际上应该是k行n列，不知道为什么还叫 nxk表
T table[count][lengthR];
cout << "\n构建初始表\n";
show(A,lengthR);
for (int k = 0;k<count;k++)
{
cout <<R[k] << "\t";
for (int j = 0;j<lengthR;j++)
{
table[k][j].col=j+1;
table[k][j].row=k+1;
if (CharIsIn(A[j], R[k]) == true)
{
table[k][j].word='a';
cout << table[k][j].word<<table[k][j].col<< "\t";
//行号不必显示，指定为一个值，用于整个列的判断
table[k][j].row=table[k][j].col ;
}
else
{
table[k][j].word='b';
//table[k][j].num=strcat(kk,jj);
cout << table[k][j].word<<table[k][j].row<<table[k][j].col<<"\t";
}
}
cout << endl;
}
for (int i=0;i<=lengthR;i++)
{
cout<<"--------";
}
cout<<endl;
//第二步：逐一考察F中的函数依赖，修改表
cout << "\n修改后的表\n";
show(A,lengthR);
bool flag1=false;
int left[8]={0},right,mini=1;//min表示最小的下标
int key=0;
for (int i=0;i<N;i++)
{
int l=fd[i].X.length();
for (int jj=0;jj<l;jj++)
{
for (int j = 0;j<lengthR;j++)
{
if (A[j]==(fd[i].X)[jj])
{
left[jj]=j;
}
//找到决定因素所在的属性列号
if (A[j]==(fd[i].Y)[jj])
{
right=j;
}
}
}
for(int k=0;k<count;k++)
{
for(int m=0;m<count;m++)
{
if (m==k){continue;}//避免自己和自己比较
for(int ll=0;ll<l;ll++)
{
if (T_equal(table[k][left[ll]],table[m][left[ll]])==true)
{
key++;
}
}
if (key==l)
{
//用来检验cout<<"("<<k+1<<"行,"<<*left+1<<"列）=（"<<m+1<<"行,"<<*left+1<<"列）"<<endl;
if(table[k][right].word=='a')
{
//则修改被决定因素所在列的对应值
table[m][right].word='a';
table[m][right].col=right+1;//修改1
table[m][right].row=table[m][right].col;
//cout<<m+1<<"行,"<<right+1<<"列->a"<<right+1<<endl;
}
else if(table[k][right].word=='b')
{
if(table[m][right].word=='a')
{
table[k][right].word='a';
//行号不必显示，指定为一个值，用于整个列的判断
table[k][right].row=table[k][right].col ;
}
else if (table[m][right].word=='b')
{
if (table[m][right].row!=1)
{
mini=min(k,m);
if (mini>table[m][right].row)mini=table[m][right].row;
}else mini=0;
table[m][right].row=mini+1;//将其值改为整列最小的
table[m][right].col=right+1;
}
}
}
key=0;
}
}
}
//显示新的表的值
for (int i=0;i<count;i++)
{
cout <<R[i] << "\t";
for (int j=0;j<lengthR;j++)
{
if (table[i][j].word=='a')
{
cout<<table[i][j].word<<table[i][j].col<<"\t";
}
else cout<<table[i][j].word<<table[i][j].row<<table[i][j].col<<"\t";
}
cout<<endl;
}
for (int i=0;i<=lengthR;i++)
{
cout<<"--------";
}
//第三步：表的结构出现特征行，或者没有变化，从而判断连接是否无损
int temp=0;
bool flag=false;
for (int i=0;i<count;i++)
{
for (int j=0;j<lengthR;j++)
{
if (table[i][j].word=='a')
{
temp++;
}
}
if (temp==lengthR)
{
flag=true;break;
}
temp=0;
}
if (flag==true) cout<<"\n该分解具有无损连接性！"<<endl;
else cout<<"\n该分解不具有无损连接性！"<<endl;
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
