normal form

3nf bcnf 4nf
video {{{1
数据库原理与技术6-3_规范格式BCNF
http://www.56.com/u28/v_NTk1Nzc5OTI.html
主属性 : 码中的属性为主属性。
非主属性 ：不在任何码中都属性为非主属性。

数据库范式(1 2 3 BCNF范式)详解
http://wenku.baidu.com/view/fba542482e3f5727a5e96292.html
即存在关键字段决定关键字段都情况，所以其不符合BCNF范式。
http://zhidao.baidu.com/link?url=1G0FhFRQNwiPvFJjouklcrzotEWwMqaLnIH_r_LVpIAGNjkRW6MaUj5JPjUdEEWqGBMamGGrxZbYiMo4txNKlq
BCNF是由Boyce和Codd提出的,比3NF又进了一步,通常认为是修正的第三范式. 　　所谓第三范式,定义是关系模式R<U,F>中若不存在这样的码X,属性组Y及非主属性Z,使得X—>Y,Y—>Z成立,(不存在Y—>X),则称R<U,F>为3NF. 　　即当2NF消除了非主属性对码的传递函数依赖，则称为3NF。 　　对3NF关系进行投影，将消除原关系中主属性对码的部分与传递依赖，得到一组BCNF关系。 　　BCNF定义,关系模式中,若X函数确定Y且Y不在X内时X必含有码,则此关系属于BCNF。 　　具有函数依赖集F的关系模式R属于BCNF的条件是，对所有F的闭包中形如 　　X－＞Y，下面至少有一个成立： 　　1X－＞Y是平凡的依赖。 　　2X是R的一个超码。 　　一个满足BCNF的关系模式有：
　　1 所有非主属性对每一个码都是完全函数依赖；
　　2 所有的主属性对每一个不包含它的码，也是完全函数依赖；
　　3 没有任何属性完全函数依赖于非码的任何一组属性。 　
　由于R∈BCNF,按定义排除了任何属性对码的传递依赖与部分依赖,所以R∈3NF。但是若R∈3NF,则R未必属于BCNF。
　　例如：关系模式STJ（S,T,J）中，S表示学生，T表示教师，J表示课程。每一个教师只教一门课。每门课有 若干个教师，某一学生选定某门课，就对应一个固定的教师。由语义可得到如下函数依赖： 　　(S,J)－＞T;(S,T)－＞j;T－＞J。
　　(S,J),(S,T)都是候选码。
　　STJ是3NF，因为没有任何非主属性对码传递依赖或部分依赖。但STJ不是BCNF关系，因为T是决定因素而T不包含码。

BCNF是建立在3nf基础上，，，怎样去理解。。。

1NF－＞没有部分依赖－＞2NF－＞没有传递依赖－＞3NF－＞所有决定因素都是候选关键字－＞BCNF

满足3NF的关系模式，每个非主属性既不部分依赖于码也不传递依赖于码。
满足BCNF的关系模式，每个决定因素都含有码。

如果一个关系模式满足BCNF，则一定满足3NF。
二者的区别在于，BCNF消除了可能存在的主属性对主码的部分依赖和传递依赖。

主属性：指主键列，即主键由一列构成
主键定义:能够唯一标识一个元组的属性或属性集，即可以由多列组成。

4nf good video.  {{{1
http://www.youtube.com/watch?v=VOknBEe1YLo   英文

http://www.tudou.com/programs/view/ExhF9ru2_Lk  中文

outer join {{{1
http://www.cnblogs.com/cy163/archive/2008/10/16/1312920.html
    http://wenku.baidu.com/view/23a969c68bd63186bcebbc6a.html
    http://www.2cto.com/database/201210/162063.html  例子

 select * from R right outer join S
union
 select * from R left outer join S ;

mysql>  select * from R right outer join S on R.B=S.B
    -> union
    ->  select * from R left outer join S on R.B=S.B;
+------+------+------+------+------+------+------+------+
| idR  | A    | B    | C    | idS  | B    | D    | E    |
+------+------+------+------+------+------+------+------+
|    1 | 1    | 2    | 3    |    1 | 2    | a    | b    |
|    2 | 5    | 2    | 6    |    1 | 2    | a    | b    |
|    4 | 3    | 7    | 4    |    2 | 7    | c    | d    |
|    4 | 3    | 7    | 4    |    4 | 7    | c    | t    |
| NULL | NULL | NULL | NULL |    3 | 9    | e    | f    |
|    3 | 1    | 3    | 4    | NULL | NULL | NULL | NULL |
+------+------+------+------+------+------+------+------+
6 rows in set (0.01 sec)

mysql> select * from R full join S;
+-----+------+------+------+-----+------+------+------+
| idR | A    | B    | C    | idS | B    | D    | E    |
+-----+------+------+------+-----+------+------+------+
|   1 | 1    | 2    | 3    |   1 | 2    | a    | b    |
|   2 | 5    | 2    | 6    |   1 | 2    | a    | b    |
|   3 | 1    | 3    | 4    |   1 | 2    | a    | b    |
|   4 | 3    | 7    | 4    |   1 | 2    | a    | b    |
|   1 | 1    | 2    | 3    |   2 | 7    | c    | d    |
|   2 | 5    | 2    | 6    |   2 | 7    | c    | d    |
|   3 | 1    | 3    | 4    |   2 | 7    | c    | d    |
|   4 | 3    | 7    | 4    |   2 | 7    | c    | d    |
|   1 | 1    | 2    | 3    |   3 | 9    | e    | f    |
|   2 | 5    | 2    | 6    |   3 | 9    | e    | f    |
|   3 | 1    | 3    | 4    |   3 | 9    | e    | f    |
|   4 | 3    | 7    | 4    |   3 | 9    | e    | f    |
|   1 | 1    | 2    | 3    |   4 | 7    | c    | t    |
|   2 | 5    | 2    | 6    |   4 | 7    | c    | t    |
|   3 | 1    | 3    | 4    |   4 | 7    | c    | t    |
|   4 | 3    | 7    | 4    |   4 | 7    | c    | t    |
+-----+------+------+------+-----+------+------+------+
16 rows in set (0.02 sec)

mysql> select * from R;
+-----+------+------+------+
| idR | A    | B    | C    |
+-----+------+------+------+
|   1 | 1    | 2    | 3    |
|   2 | 5    | 2    | 6    |
|   3 | 1    | 3    | 4    |
|   4 | 3    | 7    | 4    |
+-----+------+------+------+
4 rows in set (0.00 sec)

mysql> select * from S;
+-----+------+------+------+
| idS | B    | D    | E    |
+-----+------+------+------+
|   1 | 2    | a    | b    |
|   2 | 7    | c    | d    |
|   3 | 9    | e    | f    |
|   4 | 7    | c    | t    |
+-----+------+------+------+
4 rows in set (0.00 sec)

mysql>  select * from R natural join S;
+------+-----+------+------+-----+------+------+
| B    | idR | A    | C    | idS | D    | E    |
+------+-----+------+------+-----+------+------+
| 2    |   1 | 1    | 3    |   1 | a    | b    |
| 2    |   2 | 5    | 6    |   1 | a    | b    |
| 7    |   4 | 3    | 4    |   2 | c    | d    |
| 7    |   4 | 3    | 4    |   4 | c    | t    |
+------+-----+------+------+-----+------+------+
4 rows in set (0.00 sec)
虽然natural join(自然连接)实际上的用的比较少，但实际上这个连接是非常有用的，若能经常使用一下，实际上是非常方便的。
自然连接是在两张表中寻找那些数据类型和列名都相同的字段，然后自动地将他们连接起来，并返回所有符合条件按的结果。

begin{comment}
given an example of database scheme in 2nf but not in 3nf
provide the equivalent relational algebra query
end{comment}

---------------
    http://hi.baidu.com/qianyuanke/item/4a8a0c5de079c819aaf6d7a9
平凡函数依赖：X->Y,且Y真包含于X
非平凡依赖：X->Y,且Y不包含于X
完全函数依赖：x->Y,且没有任何一个X的子集X'能够满足X'->Y
部分函数依赖：X->Y,存在X的子集X'能够满足X'->Y
传递函数依赖：X->Y,Y->Z,YËX且Y无法决定X

http://zhidao.baidu.com/link?url=RdL8C38IBcmkLiTx5fbsakALCy2kbISNU82cEspQqLkFChnnXITGRyu4WIFZej0vaB1bFKhyUG08E72T0Ub65q
定义：设一个关系为R(U)，X和Y为属性集U上的子集，若X→Y且X不包含Y，则称X→Y为非平凡函数依赖，否则若XY则必有X→Y，称此X→Y为平凡函数依赖。　　例如：在一个职工关系中，职工号总能函数决定它本身，记作“职工号→职工号”，对于任一个给定的职工号，都有它本身的职工号值唯一对应，此为平凡函数依赖。又如：职工号和性别构成的属性子集总是能够函数决定其中的职工号或性别属性，可分别记作为“（职工号，性别）→职工号”和“（职工号，性别）→性别”，因为对于任何给定的一个元组中的职工号和性别的组合值，都唯一对应一个职工号值或性别值，不可能出现其他的职工号值或性别值，此种也为平凡函数依赖。　　通常，主要讨论的是非平凡函数依赖，即X→Y且XY。如在职工关系中，职工号函数决定其他每个属性都是非平凡函数依赖，另外“（职工号，姓名）→性别”也是非平凡函数依赖，虽然在这里由决定因素中所含的职工号单属性就能够函数决定性别，而带有的姓名属性有些多余。
http://baike.baidu.com/link?url=de94dgORrVz7DUsrTN2VXkKADUvL2QTwbxsOydJwwiU5S04w6RLCD9CLtGdHFSVGNIwbKQl97LpLQ2f3d9qclq
4NF (第四范式)
关系模式R<U，F>∈1NF，如果对于R的每个非平凡多值依赖X→→Y（Y  X），X都含有候选码，则R∈4NF。
（X→Y）
如果R ∈ 4NF， 则R ∈ BCNF
4NF就是限制关系模式的属性之间不允许有非平凡且非函数依赖的多值依赖。因为根据定义，对于每一个非平凡的多值依赖X→→Y，X都含有候选码，于是就有X→Y，所以4NF所允许的非平凡的多值依赖实际上是函数依赖。

http://zhidao.baidu.com/link?url=MdcOgSHO-Y0Shbuv0XCnvGjfCBtTw9ggXpWA8eUUxaQRfuqCyhyR2ETirzcy5rVv2Nxah0EATzX7KASFGNi2Kq
鲍依斯-科得范式（BCNF）：在第三范式的基础上，数据库表中如果不存在任何字段对任一候选关键字段的传递函数依赖则符合第三范式。
假设仓库管理关系表为StorehouseManage(仓库ID, 存储物品ID, 管理员ID, 数量)，且有一个管理员只在一个仓库工作；一个仓库可以存储多种物品。这个数据库表中存在如下决定关系： (仓库ID, 存储物品ID) →(管理员ID, 数量) (管理员ID, 存储物品ID) → (仓库ID, 数量) 所以，(仓库ID, 存储物品ID)和(管理员ID, 存储物品ID)都是StorehouseManage的候选关键字，表中的唯一非关键字段为数量，它是符合第三范式的。但是，由于存在如下决定关系： (仓库ID) → (管理员ID) (管理员ID) → (仓库ID) 即存在关键字段决定关键字段的情况，所以其不符合BCNF范式。它会出现如下异常情况： (1) 删除异常： 当仓库被清空后，所有"存储物品ID"和"数量"信息被删除的同时，"仓库ID"和"管理员ID"信息也被删除了。 (2) 插入异常： 当仓库没有存储任何物品时，无法给仓库分配管理员。 (3) 更新异常： 如果仓库换了管理员，则表中所有行的管理员ID都要修改。 把仓库管理关系表分解为二个关系表： 仓库管理：StorehouseManage(仓库ID, 管理员ID)； 仓库：Storehouse(仓库ID, 存储物品ID, 数量)。 这样的数据库表是符合BCNF范式的，消除了删除异常、插入异常和更新异常。

4nf+平凡+不平凡 描述的好 http://wenku.baidu.com/view/0a24c00d4a7302768e9939d6.html

http://wenku.baidu.com/view/0043d98c6529647d2728524b.html

 

例子很好
http://blog.csdn.net/smstong/article/details/5599490
表中，U = C+T+B，（C,T）确定一组B,但是这组B其实与T无关，仅由C确定，所以(C,T)->->B。又因为T不是空集，所以(C,T)->->B为非平凡多值依赖。

，函数依赖是多值依赖的特殊情况。

第四范式 一定要有多值依赖?
http://zhidao.baidu.com/link?url=VcKShpuH3pVvZLUaVBErab80zjPY3WFnlOoNLgoObKcwaiPM6RXh6QBzRu6z5Mt-4mOc6HayyI-0OmFpxpQmlq

http://hi.baidu.com/ayongs/item/83d6b0f766de4fde6325d2d2
BC范式、第四范式(BCNF\4NF)BC范式：
关系模式R<U，F>∈1NF，如果对于R的每个非平凡函数依赖X→→Y（Y  X），X都含有候选码，则R∈BCNF。

第四范式：

关系模式R<U，F>∈1NF，如果对于R的每个非平凡多值依赖X→→Y（Y  X），X都含有候选码，则R∈4NF。

（X→Y）

如果R ∈ 4NF， 则R ∈ BCNF

不允许有非平凡且非函数依赖的多值依赖

允许的是函数依赖（是非平凡多值依赖）
--

http://blog.csdn.net/yahohi/article/details/7529710
4.BC范式（BCNF）：

（1）所有非主属性对每一个码都是完全函数依赖；

（2）所有的主属性对于每一个不包含它的码，也是完全函数依赖；

（3）没有任何属性完全函数依赖于非码的任意一个组合。

R属于3NF，不一定属于BCNF，如果R属于BCNF，一定属于3NF。

5.第四范式（4NF）：

对于每一个X->Y，X都能找到一个候选码（ 若关系中的某一属性组的值能唯一地表示一个元组,而其真子集不行,则称该属性组为候选码）。

最后举个例子（网上的）：

学生表
学号
姓名
教师学生关系编号
系编号
爱好编号
一范式，就是表里的字段不能在划分属性了。
二范式，满足一范式基础，表里不存在与学号没关系的信息
三范式，满足二范式的基础上，表里不存在其他字段的关联，
BC范式，满足三范式的基础上，就是学生表里的每行都不存在重复的信息
第四范式，满足BC范式，就是连爱好这样字段，也不能出现 ”篮球，足球“；要建立一个爱好编号表，

--各种概念 ， 总结的好 !!!
http://en.wikipedia.org/wiki/Database_normalization
http://www.wordiq.com/definition/3NF

http://www.cs.iastate.edu/~lmiller/cs461/
http://www.cs.iastate.edu/~lmiller/cs561Old/

 

http://supportline.microfocus.com/documentation/books/sx20books/dbdyna.htm
Chapter 6: Dynamic SQL
If everything is known about a SQL statement when the application is compiled, the statement is known as a static SQL statement.

In some cases, however, the full text of a SQL statement may not be known when an application is written. For example, you may need to allow the end-user of the application to enter a SQL statement. In this case, the statement needs to be constructed at run-time. This is called a dynamic SQL statement.