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

本文探讨了数据库范式理论在程序设计中的应用,重点介绍了FplusUtils工具类,该工具类实现了函数依赖集闭包F+的计算,并提供了在属性集Ri上限定F'的算法以及函数依赖保持的判定。内容涵盖接口定义、算法实现及具体应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

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

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 Set<FunctionalDependency>F+的所有函数依赖
     */
    default Set<FunctionalDependency> Fplus(String R, Collection<FunctionalDependency> fds) {
        //存放F+的所有函数依赖
        final Set<FunctionalDependency> fplus = new HashSet<>();

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

            //再获取该闭包的所有子集
            final Collection<String> 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<FunctionalDependency> F+'
     */
    default Set<FunctionalDependency> fapostrophe(Collection<FunctionalDependency> F, String... Ris) {
        //获取函数依赖集F中的出现的属性(一般情况下=R)
        final String attributeR = attributionSequence(F);
        //计算F+
        final Set<FunctionalDependency> fplus = Fplus(attributeR, F);

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

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

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

1. 算法描述
这里写图片描述

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值