范式理论的程序设计(八)

关于数据库范式理论的程序设计 - FplusUtils

这里我使用的工具类全部都是使用接口，public interface FplusUtils extends ClosureUtils 是关于函数依赖集的闭包Ｆ+的计算及其一些应用，对前面内容的补充之一。

Utils工具的继承关系

FplusUtils接口

1. 接口声明

import com.ruoxing.dbs.bean.FunctionalDependency;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
/**
 1. @author :ruoxing
 2. @type :Interface
 3. @date :2018年6月
 4. @description :F+的计算、应用
 */
public interface FplusUtils extends ClosureUtils {
}

2.包含的方法,后面有时间会补充更多

F+的计算

这里F+的计算直接使用属性集闭包算法，而不是使用Armstrong公理。
1. 算法描述

2. 算法代码

    /**
     * 描述:F+的计算
     * @param R 关系R的属性集
     * @param fds 函数依赖集
     * @return SetF+的所有函数依赖
     */
    default Set Fplus(String R, Collection fds) {
        //存放F+的所有函数依赖
        final Set fplus = new HashSet<>();

        //求R的子集
        final Collection subsetR = combination(R);
        //遍历所有R的子集
        for (String sub1 : subsetR) {
            //对每一个的子集计算其闭包，
            final String closure = calcClosure(sub1, fds);

            //再获取该闭包的所有子集
            final Collection subsetClosure = combination(closure);

            for (String sub2 : subsetClosure) {
                //F+中添加函数依赖： 子集 → 闭包的子集
                fplus.add(new FunctionalDependency(sub1, sub2));
            }
        }
        return fplus;
    }

应用：F+在属性集Ri上的限定F’的计算

1. 算法描述
   

2. 算法代码

    /**
     * 描述:函数依赖集在分解后的Ri...上的限定
     * @param F 函数依赖集
     * @param Ris 分解后的多个模式Ri... 可变参数
     * @return Set F+'
     */
    default Set fapostrophe(Collection F, String... Ris) {
        //获取函数依赖集F中的出现的属性(一般情况下=R)
        final String attributeR = attributionSequence(F);
        //计算F+
        final Set fplus = Fplus(attributeR, F);

        //计算F+在每个Ri上的限定,的并集F+'
        final Set fapostrophe = new HashSet<>(fplus.size());
        for (String Ri : Ris) {
            fplus.forEach(dependency -> {
                if (contains(Ri, dependency.attributions())) {
                    fapostrophe.add(dependency);
                }
            });
        }
        return fapostrophe;
    }

应用：函数依赖保持的判定

前面没有介绍函数依赖保持判定的这种算法，因为很暴力。

1. 算法描述

2. 算法代码
上面算法是用于判断Ｒｉ上的函数依赖是否都被保持，这里是判定某个函数依赖是否被保持，只要修改一下就可以了。

    /**
     * 描述:依赖保持判定,使用F+
     * @param fd 某个依赖 α → β
     * @param F 函数依赖集
     * @param Ris 分解后的多个模式Ri... 可变参数
     * @return boolean
     */
    default boolean dependencyPreservingByFplus(FunctionalDependency fd,
                                                  Collection F,
                                                  String... Ris) {
        //计算F+在每个Ri上的限定,的并集F+'
        final Set fapostrophe = fapostrophe(F, Ris);
        //F'是否包含fd
        return fapostrophe.contains(fd);
    }