Database 数据库中的函数依赖关系

我对关系有以下一组函数依赖关系 模式

r（A，B，C，D，E，F）

：

A -> BCD
BC -> DE
B -> D
D -> A

---

有人能解释一下如何找到这个关系的候选键吗？

简短回答：候选键是（A，F）、（B，F）和（D，F）

就像上面说的：

可以计算所有候选密钥集，例如，从 函数依赖关系。为此，我们需要定义属性 属性集α的闭包α+。布景 α+包含所有功能上相同的属性 由α表示

找到单个候选密钥非常简单。我们从一开始 设置属性的α，并尝试依次删除每个属性 属性。如果在删除属性后，属性闭包 保持不变，则此属性不是必需的，我们可以 将其永久删除。我们称结果为最小化（α）。如果α是所有属性的集合，那么最小化（α）是一个候选键

所以现在我们只需要把它付诸实践。让我们从所有属性开始α0=（A、B、C、D、E、F）。现在我们可以看看删除A是否会产生问题。对于α'0=（B，C，D，E，F），α'0+是（B，C，D，E，F，A）（因为D&rightarrow；A成立）。现在，通过永久踢出A并尝试删除B，我们将得到一个A候选键

α1=（B，C，D，E，F）。我们能扔掉B吗？是，因为α'1=（C，D，E，F）将导致α'1+=（A，B，C，D，E，F）（因为D&rightarrow；A和A&rightarrow；BCD）

α2=（C，D，E，F）。我们能扔掉C吗？是，因为α'2=（D，E，F）将导致α'2+=（A，B，C，D，E，F）（因为D&rightarrow；A和A&rightarrow；BCD）

α3=（D，E，F）。我们能扔掉D吗？否，因为α'3=（E，F）将导致α'3+=（E，F）

α3=（D，E，F）。我们能扔掉它吗？是，因为α'3=（D，F）将导致α'3+=（A，B，C，D，E，F）（因为D&rightarrow；A；A&rightarrow；BCD；和BC&rightarrow；DE）

α4=（D，F）。我们能扔掉F吗？否，因为α'4=（D）将导致α'4+=（A，B，C，D，E）（因为D&rightarrow；A&rightarrow；BCD；和BC&rightarrow；DE）

现在我们生成了最小化（α0）=α4=（D，F）。我们可以使用蛮力方法，在每次迭代中，我们迭代所有可能移除的键。但这将花费指数级的时间来生成

然而，维基百科的文章中包含了一种生成所有候选密钥的方法，即在密钥数量和函数依赖关系中生成多项式。算法定义为：

函数查找候选键（A、F）
/*A是所有属性的集合，F是函数依赖项的集合*/
K[0]：=最小化（A）；
n:=1；/*到目前为止已知的密钥数*/
i:=0；/*当前处理的密钥*/
而我
foreachα→ β ∈ F do
/*从以前的已知密钥和当前FD构建新的潜在密钥*/
S:=α∪ （K[i]− β);
/*搜索新的潜在密钥是否是已知密钥的一部分*/
发现：=假；
对于j:=0到n-1 do
如果K[j]⊆ S然后发现：=真；
/*如果没有，请添加“如果”
如果没有找到的话
K[n]：=最小化（S）；
n:=n+1；
i:=i+1
返回K

所以如果我们运行这个算法，我们首先要计算minimize（A），但好的是：我们已经在上面做过了。所以K[0]=（D，F），n=1，i=0

现在我们进行while循环，并开始迭代所有函数依赖项

对于A&rightarrow；BCD。现在我们构造一个键（a，F）。我们检查是否已经有一个子集定义为key（实际情况并非如此）。现在我们最小化它，比如：（A，F）&rightarrow；（A，F）。因此，我们添加了一个新键（a，F）

对于BC和rightarrow；现在我们构造一个键（B，C，F）。我们检查是否已经有一个子集定义为key（实际情况并非如此）。现在我们最小化它，比如（B，C，F）&rightarrow；（B，F）和右箭头；（B，F）。所以我们加上（B，F）

对于B&rightarrow；现在我们构造一个键（B，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于D&rightarrow；现在我们构造一个键（D，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

这是第一次迭代的结束。所以现在K是K=[（D，F），（A，F），（B，F）]。n=3，现在i=1。对于K[i]=（A，F），我们现在迭代：

对于A&rightarrow；BCD。现在我们构造一个键（a，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于BC和rightarrow；现在我们构造一个键（B，C，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于B&rightarrow；现在我们构造一个键（a，B，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于D&rightarrow；现在我们构造一个键（D，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

这是第二次迭代的结束。所以现在K是K=[（D，F），（A，F），（B，F）]。n=3，现在i=2。对于K[i]=（B，F），我们现在迭代：

对于A&rightarrow；BCD。现在我们构造一个键（a，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于BC和rightarrow；现在我们构造一个键（B，C，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于B&rightarrow；现在我们构造一个键（B，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

对于D&rightarrow；现在我们构造一个键（B，D，F）。我们检查是否已经有一个子集定义为key（就是这种情况）。我们不加这个

---

所以在最后K=[（D，F），（A，F），（B，F）]。这些都是候选密钥。

你自己在这方面付出了什么努力？据我所知，我有

（ABCDE）+=ABCDE

，这意味着ABCDE的任何子集都不能形成罐头

function find_candidate_keys(A, F)
/* A is the set of all attributes and F is the set of functional dependencies */
K[0] := minimize(A);
n := 1; /* Number of Keys known so far */
i := 0; /* Currently processed key */
while i < n do
  foreach α → β ∈ F do
    /* Build a new potential key from the previous known key and the current FD */
    S := α ∪ (K[i] − β);
    /* Search whether the new potential key is part of the already known keys */ 
    found := false;
    for j := 0 to n-1 do
      if K[j] ⊆ S then found := true;
    /* If not, add if 
    if not found then
      K[n] := minimize(S);
      n := n + 1;
  i := i + 1
return K