我正在学习数据库理论课程,在阅读之后我不清楚如何在给定一组函数依赖项的情况下推断出键.
我有一个示例问题:
查找具有功能依赖关系的关系R(ABCDEFG)的所有键
AB ? C
CD ? E
EF ? G
FG ? E
DE ? C
BC ? A
通过确定以下哪一项是关键来证明您的知识.
a. BCDEF
b. ADFG
c. BDFG
d. BCDE
有人可以告诉我如何分解功能依赖关系以得出某些属性组合是关键的结论吗？我希望我会遇到很多这类问题,我需要了解如何处理它.
class (Monoid w, Monad m) => MonadWriter w m | m -> w where
pass :: m (a,w -> w) -> m a
listen :: m a -> m (a,w)
tell :: w -> m ()
上面的管道是什么意思？片段来自这里.
鉴于以下功能依赖性,我将如何计算最小覆盖:
A -> B, ABCD -> E, EF -> GH, ACDF -> EG
在讲义中,它给出了最小覆盖的推导,但我不明白.
例如摆脱ACDF - > E:
A -> B => AACD -> BACD -> E => ACD -> E => ACDF -> E
然后他们说,同样我们不保留ACDF - > G.
然后我明白ABCD - > E被推断为ACD - > E,因为A - > B,但我不明白如何达到这个的正式过程.
所以我的问题是,任何人都可以解释如何生成一组功能依赖的最小覆盖？
给定关系R与属性ABCDE.您将获得以下依赖项:A - > B,BC - > E和ED - > A.我已经有了CDE,ACD和BCD的答案.我只需要知道如何做到这一点.谢谢.
我正在努力寻找一个很好的资源来研究功能依赖和规范化.
任何人都知道我应该在哪里看？我难以区分FD是1NF,2NF还是3NF？
我一直在阅读维基百科,并使用谷歌搜索找到了很好的研究,但找不到任何简单的解释.
也许你们都可以分享你在生活中学习FD和正常化的方式.
如果我使用错误的术语,请原谅我,我是haskell类型操作的初学者...我试图使用具有功能依赖性的重叠实例来对HLists进行一些类型级编程.
这里我的目标是尝试编写类型类HNoNils l l',这HNoNils l l'意味着,l作为列表类型(例如:) Int : String : EmptyNil : Int : HNil,l'是没有特定空类型的相应列表类型EmptyNil(示例的结果:) Int:String:Int:HNil:
{-# LANGUAGE ExistentialQuantification,
FunctionalDependencies,
FlexibleInstances,
UndecidableInstances,
OverlappingInstances,
TypeFamilies #-}
import Data.HList
import Data.TypeLevel.Bool
--Type Equality operators
--usedto check if a type is equal to another
class TtEq a b eq | a b -> eq
instance TtEq a a True
instance eq~False => TtEq a b eq
data EmptyNil = EmptyNil deriving …我需要关闭这个.我制定了一个定义,部分依赖是指字段间接依赖于主键或部分依赖,但也依赖于依赖于主要的其他键,如果另一个字段依赖于id的字段被删除该字段仍将存在到期它依赖于主键.我不确定它是否正确.我已经研究过,每个定义听起来都很误导.我的定义是否正确,如果不是,请解释一下？
考虑:
{-# OPTIONS -fglasgow-exts #-}
data Second = Second
data Minute = Minute
data Hour = Hour
-- Look Ma', a phantom type!
data Time a = Time Int
instance Show (Time Second) where
show (Time t) = show t ++ "sec"
instance Show (Time Minute) where
show (Time t) = show t ++ "min"
instance Show (Time Hour) where
show (Time t) = show t ++ "hrs"
sec :: Int -> Time Second
sec t = Time t
minute …假设我有一个带有n个类型参数的类型类,我希望它们中的任何一个能够唯一地确定所有其他参数.是否足以使依赖关系形成一个循环,就像在
class Foo a b c | a -> b, b -> c, c -> a
(线性)其中有从每个参数到每个参数的路径,或者我是否需要扩展所有可能的路径,如
class Bar a b c | a -> b, a -> c, b -> a, b -> c, c -> a, c -> b
(二次)？两者之间是否有任何可观察到的差异？那怎么样？
class Baz a b c | a -> b c, b -> a c, c -> a b
为什么这会导致冲突？
class Foo a b | b -> a where
foo :: a -> b -> Bool
instance Eq a => Foo a a where
foo = (==)
instance Eq a => Foo a (a -> a) where
foo x f = f x == x
请注意,如果我删除功能依赖性,代码将编译.
我的印象是功能依赖只应该禁止像下面这样的东西,实际上,它编译!
class Foo a b | b -> a where
foo :: a -> b -> Bool
instance Eq a => Foo a a where
foo = (==)
instance Eq a => Foo …