blocks|key|2251529|text|您可能应该阅读维基百科关于功能依赖的页面:前三行可能足以澄清您的疑虑：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2251530|在关系数据库理论中，函数依赖是数据库关系中两组属性之间的约束。给定关系R，称R中的一组属性X在函数上确定另一组属性Y，也是在R中，(写X→Y)当且仅当每个X值与一个Y值精确相关联，则称R满足函数依赖X→Y。|blockquote|2251531|但是，在您的示例中，X+必须有不同的值，因为它是关键，而Y可以是任何值，而它恰好总是10。|style|CODE|BOLD|2251532|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Functional_dependency^0|D|4|0|0|0|A|1|S|1|C|X|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|C|$]]|$1|G|3|H|5|6|7|Y|8|@$A|Z|B|10|I|J]|$A|11|B|12|I|J]|$A|13|B|14|I|K]]|9|@]|C|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

You should probably read the wikipedia page about <a href="http://en.wikipedia.org/wiki/Functional_dependency" rel="nofollow">functional dependencies</a>: the first three lines are probably enough to clarify your doubt: 

<blockquote>
 In relational database theory, a functional dependency is a constraint between two sets of attributes in a relation from a database.
 Given a relation R, a set of attributes X in R is said to functionally determine another set of attributes Y, also in R, (written X → Y) if, and only if, each X value is associated with precisely one Y value; R is then said to satisfy the functional dependency X → Y.
</blockquote>

However, in your example <code>X</code> must have different values since it is the key, whereas <code>Y</code> could be any value and it just happens to be always 10.

blocks|key|1533524|text|当关系“是函数”时，函数依赖发生在关系中。形式上，这意味着如果您有像X+->+Y这样的FD，那么X的每个值都必须与Y的确切值1相关联。如果我们颠倒了这一说法，我们就会得到一个关于FD失败的“测试”：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1533525|If+there+exists+a+value+`x`+in+`X`+such+that+there+are+two+values+
of+`Y`,+`y1`+and+`y2`,+where+both

++(x,+y1)+and+(x,+y2)

are+in+the+relation,+if+`NOT+(y1+==+y2)`+then+`Y`+is+not+
functionally+dependent+on+`X`|code-block|syntax|javascript|1533526|经过一点思考，很容易看出这个测试通过了您所写的关系。|1533527|X+->+Y的一个更直观的概念来自于对数学函数的直觉。函数可以看作是一台机器，它消耗输入并产生输出，其规则是，无论运行多少次，特定输入的输出总是相同的。关系模型在具有函数依赖时起作用。函数依赖只表示关系中的元组可以具有以下形式|1533528|(x,+f(x))|1533529|对于一些数学函数，f。|1533530|就您的关系而言，该函数f很简单：|1533531|f(x)+=+10+++++++++++"constant+function"

Examples:
f(1)++=+10
f(2)++=+10
f(10)+=+10|1533532|FD的另一个概念来自于“绘图图”。为此，请将X的所有值都放在Y值旁边的一行中。|1533533|x1++++y1
x2++++y2
x3++++y3
x4++++y4
x5++++y5
...|1533534|当我们将两个值从X列绘制到连接两个值的Y列时，就会发生关系。每一行对应一个元组。|1533535|x1----y1++++++is+the+relation++++++++{+(x1,+y1),+(x2,+y2)+}
x2----y2|1533536|如果X+->+Y的每个值都有0行或1行关联，那么关系就是函数式的X。|1533537|x1----y1+++is+the+relation+{+(x1,+y1)
x2----y2+++++++++++++++++++,+(x2,+y2)
x3--%7C+y3+++++++++++++++++++,+(x3,+y4)
x4--%2B-y4+++++++++++++++++++,+(x4,+y4)+}|1533538|在这种情况下，我们可以将这些行转换为“箭头”。|1533539|x1---->y1
x2---->y2
x3--%7C++y3
x4--%2B->y4|1533540|如果我们沿着箭头从一个基地到另一个点，我们总是有一条独特的前进路径--我们不需要“分裂”。在非函数关系中，我们“拆分”；例如，如果我们翻转关系，看看Y是否在X上起作用，我们就会翻转箭头。|1533541|x1<----y1
x2<----y2
x3<--%7C+y3
x4<--%2B-y4|1533542|现在，当我们离开y4离开的时候，我们必须“拆分”，沿着箭头走到x3和x4。这意味着Y+->+X不起作用。|1533543|entityMap^0|Y|6|1C|1|1L|1|0|0|0|0|6|0|0|9|1|0|B|1|0|0|M|1|U|1|0|0|8|1|J|1|0|0|2|6|W|1|0|0|0|0|22|1|26|1|0|0|8|2|V|2|Y|2|15|6|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1S|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|23|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|24|8|@$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|12|3|13|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|2G|8|@$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|16|3|17|5|H|7|2L|8|@]|D|@]|E|$I|J]]|$1|18|3|19|5|6|7|2M|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|2N|8|@]|D|@]|E|$I|J]]|$1|1C|3|1D|5|6|7|2O|8|@$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|H|7|2T|8|@]|D|@]|E|$I|J]]|$1|1G|3|1H|5|6|7|2U|8|@$9|2V|A|2W|B|C]|$9|2X|A|2Y|B|C]|$9|2Z|A|30|B|C]|$9|31|A|32|B|C]]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|33|8|@]|D|@]|E|$]]]|1J|$]]

Functional dependency happens in a relation when the relation "is a function". Formally, this means that if you have an FD like <code>X -&gt; Y</code> then each value of <code>X</code> must relate to exactly 1 value of <code>Y</code>. If we invert that statement, we get a "test" for a failure to have an FD:

<pre><code>If there exists a value `x` in `X` such that there are two values 
of `Y`, `y1` and `y2`, where both

 (x, y1) and (x, y2)

are in the relation, if `NOT (y1 == y2)` then `Y` is not 
functionally dependent on `X`
</code></pre>

With a bit of thought it's easy to see that this test passes for the relation you've written down.

<hr>

A more intuitive notion of <code>X -&gt; Y</code> comes from intuition about mathematical functions. A function can be thought of as a machine which consumes input and produces output under the rule that the output of some particular input is always the same no matter how many times you run the machine. Relations model functions when they have functional dependencies. A functional dependency just states that the tuples in your relation could have the form

<pre><code>(x, f(x))
</code></pre>

for some mathematical function <code>f</code>.

In the case of your relation, that function <code>f</code> is simple:

<pre><code>f(x) = 10 "constant function"

Examples:
f(1) = 10
f(2) = 10
f(10) = 10
</code></pre>

<hr>

Another notion of FD comes from "drawing diagrams". To do this, think of all the values of <code>X</code> as being laid out in a line next to all the values of <code>Y</code>

<pre><code>x1 y1
x2 y2
x3 y3
x4 y4
x5 y5
...
</code></pre>

A relation occurs when we draw lines from the <code>X</code> column to the <code>Y</code> column connecting two values. Each line corresponds to a tuple.

<pre><code>x1----y1 is the relation { (x1, y1), (x2, y2) }
x2----y2
</code></pre>

A relation is functional <code>X -&gt; Y</code> if each value of <code>X</code> has either 0 or 1 lines associated with it.

<pre><code>x1----y1 is the relation { (x1, y1)
x2----y2 , (x2, y2)
x3--| y3 , (x3, y4)
x4--+-y4 , (x4, y4) }
</code></pre>

When this is the case we can turn these lines into "arrows"

<pre><code>x1----&gt;y1
x2----&gt;y2
x3--| y3
x4--+-&gt;y4
</code></pre>

and have the property where if we follow the arrows from base to point we always have a unique path forward---we don't have to "split up". In a non-functional relation we "split up"; for instance, if we flip the relation and look to see if <code>Y</code> is functional on <code>X</code> we flip the arrows

<pre><code>x1&lt;----y1
x2&lt;----y2
x3&lt;--| y3
x4&lt;--+-y4
</code></pre>

and now see that as we leave <code>y4</code> traveling left we'd have to "split" to follow the arrow to both <code>x3</code> and <code>x4</code>. This means that <code>Y -&gt; X</code> does not hold.

In FD, I do not understand the following: X->Y, how come X could be different as long as the Y is the same?

<pre><code>X Y
-- --
1 10
2 10
3 10
</code></pre>

I was told that this is still X->Y and that it only matters if Y changed. I do not get it..

FD X->Y, various X do not matter?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在FD中，我不明白: X->Y，为什么X可以是不同的，只要Y是相同的？X   Y--  --1   102   103   10有人告诉我，这仍然是X->Y，只有Y变了才有关系.我不明白..。

问FD X->Y，各种X不重要吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问FD X->Y，各种X不重要吗？EN