对操作系统而言,在进程Terminate之后回收进程占用的全部资源是最基本的要求.在一个程序结束(无论是怎么结束的)时,它所占用的内存会全部被释放.也就是说,如果windows的设计是正确的,那么所谓"被浪费的是硬盘上的空间"这种情况是绝对不可能出现的.如果出现,那么就是windows的一个特大bug.而windows是否真的有这个问题,第一,没有类似的报告.第二,我们也看不到windows的源代码.有兴趣的可以去看看Linux的代码,是如何管理内存的.
内存泄漏是指这样一种情况:按照设计,程序在完成一个任务之后应当不会占用更多的内存,但事实是占用变多了.引起内存泄漏的基本原因,就是在new以后没有delete(malloc以后没有free).java有垃圾回收机制,但显然,这是以牺牲性能为代价的,对响应要求高的环境下,这恐怕是通不过的.
另外,操作系统是不能自动回收进程占用的内存,除非进程显式的通知操作系统放弃某块空间,操作系统并不负责检查进程中每一部分的使用情况(它也不能负责,操作系统是不会知道进程中有些什么变量的).java的回收是进程本身的一种自动检查功能,和操作系统完全无关.
posted @
2008-11-21 23:33 Benson 阅读(522) |
评论 (0) |
编辑 收藏
回调函数是应用程序提供给Windows系统DLL或其它DLL调用的函数，一般用于截获消息、获取系统信息或处理异步事件。应用程序把回调函数的地址指针告诉DLL，而DLL在适当的时候会调用该函数。回调函数必须遵守事先规定好的参数格式和传递方式，否则DLL一调用它就会引起程序或系统的崩溃。通常情况下，回调函数采用标准WindowsAPI的调用方式，即__stdcall，当然，DLL编制者可以自己定义调用方式，但客户程序也必须遵守相同的规定。在__stdcall方式下，函数的参数按从右到左的顺序压入堆栈，除了明确指明是指针或引用外，参数都按值传递，函数返回之前自己负责把参数从堆栈中弹出。
理解回调函数!
程序在调用一个函数(function)时(通常指api).相当于程序(program)呼叫(Call)了一个函数(function)关系表示如下:
call(调用)
program --------------------→ dll
程序在调用一个函数时，将自己的函数的地址作为参数传递给程序调用的函数时（那么这个自己的函数称回调函数）.需要回调函数的 DLL 函数往往是一些必须重复执行某些操作的函数.关系表示如下:
call(调用)
program --------------------→ dll
↑ ￤
￤_______________________________￤
callback(回调)
当你调用的函数在传递返回值给回调函数时,你就可以利用回调函数来处理或完成一定的操作。至于如何定义自己的回调函数，跟具体使用的API函数有关，很多不同类别的回调函数有各种各样的参数，有关这些参数的描述一般在帮助中有说明回调函数的参数和返回值等.其实简单说回调函数就是你所写的函数满足一定条件后，被DLL调用!
也有这样的说法(比较容易理解):
回调函数就好像是一个中断处理函数，系统在符合你设定的条件时自动调用。为此，你需要做三件事：
1. 声明；
2. 定义；
3. 设置触发条件，就是在你的函数中把你的回调函数名称转化为地址作为一个参数，以便于DLL调用。
posted @
2008-11-21 20:42 Benson 阅读(657) |
评论 (0) |
编辑 收藏SQL 里面最常用的命令是 SELECT 语句，用于检索数据。语法是：
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
[ INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table ]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT [ ALL ] } select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ FOR UPDATE [ OF class_name [, ...] ] ]
[ LIMIT { count | ALL } [ { OFFSET | , } start ]]
现在我们将通过不同的例子演示 SELECT 语句复杂的语法。用于这些例子的表在 供应商和部件数据库 里定义。
这里是一些使用 SELECT 语句的简单例子：
Example 1-4. 带有条件的简单查询
要从表 PART 里面把字段 PRICE 大于 10 的所有记录找出来， 我们写出下面查询：
SELECT * FROM PART
WHERE PRICE > 10;
然后得到表：
PNO | PNAME | PRICE
-----+---------+--------
3 | Bolt | 15
4 | Cam | 25
在 SELECT语句里使用 "*" 将检索出表中的所有属性。 如果我们只希望从表 PART 中检索出属性 PNAME 和 PRICE， 我们使用下面的语句：
SELECT PNAME, PRICE
FROM PART
WHERE PRICE > 10;
这回我们的结果是：
PNAME | PRICE
--------+--------
Bolt | 15
Cam | 25
请注意
SQL 的 SELECT 语句对应关系演算里面的 "projection" （映射），而不是 "selection"（选择）（参阅
关系演算 获取详细信息）。
WHERE 子句里的条件也可以用关键字 OR，AND，和 NOT 逻辑地连接起来：
SELECT PNAME, PRICE
FROM PART
WHERE PNAME = 'Bolt' AND
(PRICE = 0 OR PRICE <= 15);
这样将生成下面的结果：
PNAME | PRICE
--------+--------
Bolt | 15
目标列表和 WHERE 子句里可以使用算术操作。例如， 如果我们想知道如果我们买两个部件的话要多少钱， 我们可以用下面的查询：
SELECT PNAME, PRICE * 2 AS DOUBLE
FROM PART
WHERE PRICE * 2 < 50;
这样我们得到：
PNAME | DOUBLE
--------+---------
Screw | 20
Nut | 16
Bolt | 30
请注意在关键字 AS 后面的 DOUBLE 是第二个列的新名字。 这个技巧可以用于目标列表里的每个元素， 给它们赋予一个在结果列中显示的新的标题。 这个新的标题通常称为别名。这个别名不能在该查询的其他地方使用。
下面的例子显示了 SQL 里是如何实现连接的。
要在共同的属性上连接三个表 SUPPLIER，PART 和 SELLS， 我们通常使用下面的语句：
SELECT S.SNAME, P.PNAME
FROM SUPPLIER S, PART P, SELLS SE
WHERE S.SNO = SE.SNO AND
P.PNO = SE.PNO;
而我们得到的结果是：
SNAME | PNAME
-------+-------
Smith | Screw
Smith | Nut
Jones | Cam
Adams | Screw
Adams | Bolt
Blake | Nut
Blake | Bolt
Blake | Cam
在 FROM 子句里，我们为每个关系使用了一个别名， 因为在这些关系间有着公共的命名属性（SNO 和 PNO）。 现在我们可以区分不同表的公共命名属性， 只需要简单的用每个关系的别名加上个点做前缀就行了。 联合是用与 一个内部联接 里显示的同样的方法计算的。首先算出笛卡儿积 SUPPLIER × PART × SELLS 。然后选出那些满足 WHERE 子句里给出的条件的记录 （也就是说，公共命名属性的值必须相等）。 最后我们映射出除 S.SNAME 和 P.PNAME 外的所有属性。
另外一个进行连接的方法是使用下面这样的 SQL JOIN 语法：
select sname, pname from supplier
JOIN sells USING (sno)
JOIN part USING (pno);
giving again:
sname | pname
-------+-------
Smith | Screw
Adams | Screw
Smith | Nut
Blake | Nut
Adams | Bolt
Blake | Bolt
Jones | Cam
Blake | Cam
(8 rows)
一个用 JOIN 语法创建的连接表，是一个出现在 FROM 子句里的， 在任何 WHERE，GROUP BY 或 HAVING 子句之前的表引用列表项． 其它表引用，包括表名字或者其它 JOIN 子句，如果用逗号分隔的话， 可以包含在 FROM 子句里． 连接生成的表逻辑上和任何其它在 FROM 子句里列出的表都一样．
SQL JOIN 有两种主要类型，CROSS JOIN (无条件连接) 和条件连接．条件连接还可以根据声明的 连接条件(ON，USING，或 NATURAL)和它 应用的方式(INNER 或 OUTER 连接)进一步细分．
连接类型
- CROSS JOIN
-
{ T1 } CROSS JOIN { T2 }
一个交叉连接（cross join）接收两个分别有 N 行和 M 行 的表 T1 和 T2，然后返回一个包含交叉乘积 NxM 条记录的 连接表． 对于 T1 的每行 R1，T2 的每行 R2 都与 R1 连接生成 连接的表行 JR，JR 包含所有 R1 和 R2 的字段． CROSS JOIN 实际上就是一个 INNER JOIN ON TRUE．
- 条件 JOIN
-
{ T1 } [ NATURAL ] [ INNER | { LEFT | RIGHT | FULL } [ OUTER ] ] JOIN { T2 } { ON search condition | USING ( join column list ) }
一个条件 JOIN 必须通过提供一个(并且只能有一个) NATURAL，ON，或者 USING 这样的关键字来声明它的 连接条件． ON 子句 接受一个 search condition， 它与一个 WHERE 子句相同．USING 子句接受一个用逗号分隔的 字段名列表，连接表中必须都有这些字段， 并且用那些字段连接这些表，生成的连接表包含每个共有字段 和两个表的所有其它字段． NATURAL 是 USING 子句的缩写，它列出两个表中所有公共 的字段名字．使用 USING 和 NATURAL 的副作用是 每个连接的字段都只有一份拷贝出现在结果表中 (与前面定义的关系演算的 JOIN 相比较)．
-
[ INNER ] JOIN
-
对于 T1 的每行 R1，连接成的表在 T2 里都有一行满 足与 R1 一起的连接条件．
对于所有 JOIN 而言，INNER 和 OUTER 都是可选的．INNER 是缺省． LEFT，RIGHT，和 FULL 只用于 OUTER JOIN．
-
LEFT [ OUTER ] JOIN
-
首先，执行一次 INNER JOIN． 然后，如果 T1 里有一行对任何 T2 的行都不满足 连接条件，那么返回一个连接行，该行的 T2 的字段 为 null．
小技巧: 连接成的表无条件地包含 T1 里的所有行．
-
RIGHT [ OUTER ] JOIN
-
首先，执行一次 INNER JOIN． 然后，如果 T2 里有一行对任何 T1 的行都不满足 连接条件，那么返回一个连接行，该行的 T1 的字段 为 null．
小技巧: 连接成的表无条件地包含 T2 里的所有行．
-
FULL [ OUTER ] JOIN
-
首先，执行一次 INNER JOIN． 然后，如果 T1 里有一行对任何 T2 的行都不满足 连接条件，那么返回一个连接行，该行的 T1 的字段 为 null． 同样，如果 T2 里有一行对任何 T1 的行都不满足 连接条件，那么返回一个连接行，该行的 T2 的字段 为 null．
小技巧: 连接成的表无条件地拥有来自 T1 的每 一行和来自 T2 的每一行．
所有 类型的 JOIN 都可以链接在一起或者嵌套在一起， 这时 T1 和 T2 都可以是连接生成的表．我们可以使用圆括弧控制 JOIN 的顺序，如果我们不主动控制，那么连接顺序是从左到右．
SQL 提供以一些聚集操作符（如， AVG，COUNT，SUM，MIN，MAX），这些聚集操作符以一个表达式为参数。 只要是满足 WHERE 子句的行，就会计算这个表达式， 然后聚集操作符对这个输入数值的集合进行计算． 通常，一个聚集对整个 SELECT 语句计算的结果是 生成一个结果．但如果在一个查询里面声明了分组， 那么数据库将对每个组进行一次独立的计算，并且 聚集结果是按照各个组出现的(见下节)．
Example 1-5. 聚集
果我们想知道表 PART 里面所有部件的平均价格，我们可以使用下面查询：
SELECT AVG(PRICE) AS AVG_PRICE
FROM PART;
结果是：
AVG_PRICE
-----------
14.5
如果我们想知道在表 PART 里面存储了多少部件，我们可以使用语句：
SELECT COUNT(PNO)
FROM PART;
得到：
COUNT
-------
4
SQL 允许我们把一个表里面的记录分成组。 然后上面描述的聚集操作符可以应用于这些组上 （也就是说，聚集操作符的值不再是对所有声明的列的值进行操作， 而是对一个组的所有值进行操作。这样聚集函数是为每个组独立地进行计算的。）
对记录的分组是通过关键字 GROUP BY 实现的，GROUP BY 后面跟着一个定义组的构成的属性列表。 如果我们使用语句 GROUP BY A1, ⃛, Ak 我们就把关系分成了组，这样当且仅当两条记录在所有属性 A1, ⃛, Ak 上达成一致，它们才是同一组的。
Example 1-6. 聚集
如果我们想知道每个供应商销售多少个部件，我们可以这样写查询：
SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
FROM SUPPLIER S, SELLS SE
WHERE S.SNO = SE.SNO
GROUP BY S.SNO, S.SNAME;
得到：
SNO | SNAME | COUNT
-----+-------+-------
1 | Smith | 2
2 | Jones | 1
3 | Adams | 2
4 | Blake | 3
然后我们看一看发生了什么事情。首先生成表 SUPPLIER 和 SELLS 的连接：
S.SNO | S.SNAME | SE.PNO
-------+---------+--------
1 | Smith | 1
1 | Smith | 2
2 | Jones | 4
3 | Adams | 1
3 | Adams | 3
4 | Blake | 2
4 | Blake | 3
4 | Blake | 4
然后我们把那些属性 S.SNO 和 S.SNAME 相同的记录放在组中：
S.SNO | S.SNAME | SE.PNO
-------+---------+--------
1 | Smith | 1
| 2
--------------------------
2 | Jones | 4
--------------------------
3 | Adams | 1
| 3
--------------------------
4 | Blake | 2
| 3
| 4
在我们的例子里，我们有四个组并且现在我们可以对每个组应用聚集操作符 COUNT，生成上面给出的查询的最终结果。
请注意如果要让一个使用 GROUP BY 和聚集操作符的查询的结果有意义， 那么用于分组的属性也必须出现在目标列表中。 所有没有在 GROUP BY 子句里面出现的属性都只能通过使用聚集函数来选择。 否则就不会有唯一的数值与其它字段关联．
还要注意的是在聚集上聚集是没有意义的，比如，AVG(MAX(sno))， 因为 SELECT 只做一个回合的分组和聚集．你可以获得这样的结果， 方法是使用临时表或者在 FROM 子句中使用一个子 SELECT 做第一个层次的聚集．
HAVING 子句运做起来非常象 WHERE 子句， 只用于对那些满足 HAVING 子句里面给出的条件的组进行计算。 其实，WHERE 在分组和聚集之前过滤掉我们不需要的输入行， 而 HAVING 在 GROUP 之后那些不需要的组． 因此，WHERE 无法使用一个聚集函数的结果． 而另一方面，我们也没有理由写一个不涉及聚集函数的 HAVING． 如果你的条件不包含聚集，那么你也可以把它写在 WHERE 里面， 这样就可以避免对那些你准备抛弃的行进行的聚集运算．
Example 1-7. Having
如果我们想知道那些销售超过一个部件的供应商，使用下面查询：
SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
FROM SUPPLIER S, SELLS SE
WHERE S.SNO = SE.SNO
GROUP BY S.SNO, S.SNAME
HAVING COUNT(SE.PNO) > 1;
and get:
SNO | SNAME | COUNT
-----+-------+-------
1 | Smith | 2
3 | Adams | 2
4 | Blake | 3
在 WHERE 和 HAVING 子句里，允许在任何要产生数值的地方使用子查询 （子选择）。 这种情况下，该值必须首先来自对子查询的计算。子查询的使用扩展了 SQL 的表达能力。
Example 1-8. 子查询
如果我们想知道所有比名为 'Screw' 的部件贵的部件，我们可以用下面的查询：
SELECT *
FROM PART
WHERE PRICE > (SELECT PRICE FROM PART
WHERE PNAME='Screw');
结果是：
PNO | PNAME | PRICE
-----+---------+--------
3 | Bolt | 15
4 | Cam | 25
当我们检查上面的查询时会发现出现了两次 SELECT 关键字。 第一个在查询的开头 - 我们将称之为外层 SELECT - 而另一个在 WHERE 子句里面，成为一个嵌入的查询 - 我们将称之为内层 SELECT。 对外层 SELECT 的每条记录都必须先计算内层 SELECT。在完成所有计算之后， 我们得知名为 'Screw' 部件的记录的价格， 然后我们就可以检查那些价格更贵的记录了。 (实际上，在本例中，内层查询只需要执行一次， 因为它不依赖于外层查询高等状态．)
如果我们想知道那些不销售任何部件的供应商 （比如说，我们想把这些供应商从数据库中删除），我们用：
SELECT *
FROM SUPPLIER S
WHERE NOT EXISTS
(SELECT * FROM SELLS SE
WHERE SE.SNO = S.SNO);
在我们的例子里，结果列将是空的，因为每个供应商至少销售一个部件。 请注意我们在 WHERE 子句的内层 SELECT 里使用了来自外层 SELECT 的 S.SNO。 正如前面所说的，子查询为每个外层查询计算一次，也就是说， S.SNO 的值总是从外层 SELECT 的实际记录中取得的。
一种有些特别的子查询的用法是把它们放在 FROM 子句里． 这个特性很有用，因为这样的子查询可以输出多列和多行， 而在表达式里使用的子查询必须生成一个结果． FROM 里的子查询还可以让我们获得多于一个回合的分组/聚集特性， 而不需要求助于临时表．
Example 1-9. FROM 里面的子查询
如果我们想知道在所有我们的供应商中的最高平均部件价格的那家， 我们不能用 MAX(AVG(PRICE))，但我们可以这么写：
SELECT MAX(subtable.avgprice)
FROM (SELECT AVG(P.PRICE) AS avgprice
FROM SUPPLIER S, PART P, SELLS SE
WHERE S.SNO = SE.SNO AND
P.PNO = SE.PNO
GROUP BY S.SNO) subtable;
这个子查询为每个供应商返回一行（因为它的 GROUP BY） 然后我们在外层查询对所有行进行聚集．
这些操作符分别计算两个子查询产生的元组的联合，相交和集合理论里的相异。
Example 1-10. Union, Intersect, Except
下面的例子是 UNION 的例子：
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNAME = 'Jones'
UNION
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNAME = 'Adams';
产生结果：
SNO | SNAME | CITY
-----+-------+--------
2 | Jones | Paris
3 | Adams | Vienna
下面是相交（ INTERSECT）的例子：
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 1
INTERSECT
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO < 3;
产生结果：
SNO | SNAME | CITY
-----+-------+--------
2 | Jones | Paris
两个查询都会返回的元组是那条 SNO=2 的
最后是一个 EXCEPT 的例子：
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 1
EXCEPT
SELECT S.SNO, S.SNAME, S.CITY
FROM SUPPLIER S
WHERE S.SNO > 3;
结果是：
SNO | SNAME | CITY
-----+-------+--------
2 | Jones | Paris
3 | Adams | Vienna
posted @
2008-11-21 17:00 Benson 阅读(1048) |
评论 (0) |
编辑 收藏/****strlen.c - contains strlen() routine
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* strlen returns the length of a null-terminated string,
* not including the null byte itself.
*
*******************************************************************************/
#include <cruntime.h>
#include <string.h>
#ifdef _MSC_VER
#pragma function(strlen)
#endif /* _MSC_VER */
/****strlen - return the length of a null-terminated string
*
*Purpose:
* Finds the length in bytes of the given string, not including
* the final null character.
*
*Entry:
* const char * str - string whose length is to be computed
*
*Exit:
* length of the string "str", exclusive of the final null byte
*
*Exceptions:
*
*******************************************************************************/
size_t __cdecl strlen (
const char * str
)
{
const char *eos = str;
while( *eos++ );
return( (int)(eos - str - 1) );
}
posted @
2008-11-21 12:39 Benson 阅读(623) |
评论 (0) |
编辑 收藏
/**//****strcat.c - contains strcat() and strcpy()
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* Strcpy() copies one string onto another.
*
* Strcat() concatenates (appends) a copy of the source string to the
* end of the destination string, returning the destination string.
*
*******************************************************************************/
#include <cruntime.h>
#include <string.h>
#ifndef _MBSCAT
#ifdef _MSC_VER
#pragma function(strcat,strcpy)
#endif /* _MSC_VER */
#endif /* _MBSCAT */
/**//****char *strcat(dst, src) - concatenate (append) one string to another
*
*Purpose:
* Concatenates src onto the end of dest. Assumes enough
* space in dest.
*
*Entry:
* char *dst - string to which "src" is to be appended
* const char *src - string to be appended to the end of "dst"
*
*Exit:
* The address of "dst"
*
*Exceptions:
*
*******************************************************************************/
char * __cdecl strcat (
char * dst,
const char * src
)
{
char * cp = dst;
while( *cp )
cp++; /**//* find end of dst */
while( *cp++ = *src++ ) ; /**//* Copy src to end of dst */
return( dst ); /**//* return dst */
}
/**//****char *strcpy(dst, src) - copy one string over another
*
*Purpose:
* Copies the string src into the spot specified by
* dest; assumes enough room.
*
*Entry:
* char * dst - string over which "src" is to be copied
* const char * src - string to be copied over "dst"
*
*Exit:
* The address of "dst"
*
*Exceptions:
*******************************************************************************/
char * __cdecl strcpy(char * dst, const char * src)
{
char * cp = dst;
while( *cp++ = *src++ ); /**//* Copy src over dst */
return( dst );
}posted @
2008-11-21 12:34 Benson 阅读(1739) |
评论 (0) |
编辑 收藏
/**//****strcmp.c - routine to compare two strings (for equal, less, or greater)
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* Compares two string, determining their lexical order.
*
*******************************************************************************/
#include <cruntime.h>
#include <string.h>
#ifdef _MSC_VER
#pragma function(strcmp)
#endif /* _MSC_VER */
/**//***
*strcmp - compare two strings, returning less than, equal to, or greater than
*
*Purpose:
* STRCMP compares two strings and returns an integer
* to indicate whether the first is less than the second, the two are
* equal, or whether the first is greater than the second.
*
* Comparison is done byte by byte on an UNSIGNED basis, which is to
* say that Null (0) is less than any other character (1-255).
*
*Entry:
* const char * src - string for left-hand side of comparison
* const char * dst - string for right-hand side of comparison
*
*Exit:
* returns -1 if src < dst
* returns 0 if src == dst
* returns +1 if src > dst
*
*Exceptions:
*
*******************************************************************************/
int __cdecl strcmp (
const char * src,
const char * dst
)
{
int ret = 0 ;
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
++src, ++dst;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}
posted @
2008-11-21 12:29 Benson 阅读(1018) |
评论 (0) |
编辑 收藏
数据库的设计范式是数据库设计所需要满足的规范，满足这些规范的数据库是简洁的、结构明晰的，同时，不会发生插入（insert）、删除（delete）和更新（update）操作异常。反之则是乱七八糟，不仅给数据库的编程人员制造麻烦，而且面目可憎，可能存储了大量不需要的冗余信息。
设计范式是不是很难懂呢？非也，大学教材上给我们一堆数学公式我们当然看不懂，也记不住。所以我们很多人就根本不按照范式来设计数据库。
实质上，设计范式用很形象、很简洁的话语就能说清楚，道明白。本文将对范式进行通俗地说明，并以笔者曾经设计的一个简单论坛的数据库为例来讲解怎样将这些范式应用于实际工程。
范式说明
第一范式（1NF）：数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。
例如，如下的数据库表是符合第一范式的：
而这样的数据库表是不符合第一范式的：
| 字段1 |
字段2 |
字段3 |
字段4 |
| |
|
字段3.1 |
字段3.2 |
|
很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。
第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。
假定选课关系表为SelectCourse(学号, 姓名, 年龄, 课程名称, 成绩, 学分)，关键字为组合关键字(学号, 课程名称)，因为存在如下决定关系：
(学号, 课程名称) → (姓名, 年龄, 成绩, 学分)
这个数据库表不满足第二范式，因为存在如下决定关系：
(课程名称) → (学分)
(学号) → (姓名, 年龄)
即存在组合关键字中的字段决定非关键字的情况。
由于不符合2NF，这个选课关系表会存在如下问题：
(1) 数据冗余：
同一门课程由n个学生选修，"学分"就重复n-1次；同一个学生选修了m门课程，姓名和年龄就重复了m-1次。
(2) 更新异常：
若调整了某门课程的学分，数据表中所有行的"学分"值都要更新，否则会出现同一门课程学分不同的情况。
(3) 插入异常：
假设要开设一门新的课程，暂时还没有人选修。这样，由于还没有"学号"关键字，课程名称和学分也无法记录入数据库。
(4) 删除异常：
假设一批学生已经完成课程的选修，这些选修记录就应该从数据库表中删除。但是，与此同时，课程名称和学分信息也被删除了。很显然，这也会导致插入异常。
把选课关系表SelectCourse改为如下三个表：
学生：Student(学号, 姓名, 年龄)；
课程：Course(课程名称, 学分)；
选课关系：SelectCourse(学号, 课程名称, 成绩)。
这样的数据库表是符合第二范式的，消除了数据冗余、更新异常、插入异常和删除异常。
另外，所有单关键字的数据库表都符合第二范式，因为不可能存在组合关键字。
第三范式（3NF）：在第二范式的基础上，数据表中如果不存在非关键字段对任一候选关键字段的传递函数依赖则符合第三范式。所谓传递函数依赖，指的是如果存在"A → B → C"的决定关系，则C传递函数依赖于A。因此，满足第三范式的数据库表应该不存在如下依赖关系：
关键字段 → 非关键字段x → 非关键字段y
假定学生关系表为Student(学号, 姓名, 年龄, 所在学院, 学院地点, 学院电话)，关键字为单一关键字"学号"，因为存在如下决定关系：
(学号) → (姓名, 年龄, 所在学院, 学院地点, 学院电话)
这个数据库是符合2NF的，但是不符合3NF，因为存在如下决定关系：
(学号) → (所在学院) → (学院地点, 学院电话)
即存在非关键字段"学院地点"、"学院电话"对关键字段"学号"的传递函数依赖。
它也会存在数据冗余、更新异常、插入异常和删除异常的情况，读者可自行分析得知。
把学生关系表分为如下两个表：
学生：(学号, 姓名, 年龄, 所在学院)；
学院：(学院, 地点, 电话)。
这样的数据库表是符合第三范式的，消除了数据冗余、更新异常、插入异常和删除异常。
鲍依斯-科得范式（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范式的，消除了删除异常、插入异常和更新异常。
范式应用
我们来逐步搞定一个论坛的数据库，有如下信息：
（1） 用户：用户名，email，主页，电话，联系地址
（2） 帖子：发帖标题，发帖内容，回复标题，回复内容
第一次我们将数据库设计为仅仅存在表：
| 用户名 |
email |
主页 |
电话 |
联系地址 |
发帖标题 |
发帖内容 |
回复标题 |
回复内容 |
这个数据库表符合第一范式，但是没有任何一组候选关键字能决定数据库表的整行，唯一的关键字段用户名也不能完全决定整个元组。我们需要增加"发帖ID"、"回复ID"字段，即将表修改为：
| 用户名 |
email |
主页 |
电话 |
联系地址 |
发帖ID |
发帖标题 |
发帖内容 |
回复ID |
回复标题 |
回复内容 |
这样数据表中的关键字(用户名，发帖ID，回复ID)能决定整行：
(用户名,发帖ID,回复ID) → (email,主页,电话,联系地址,发帖标题,发帖内容,回复标题,回复内容)
但是，这样的设计不符合第二范式，因为存在如下决定关系：
(用户名) → (email,主页,电话,联系地址)
(发帖ID) → (发帖标题,发帖内容)
(回复ID) → (回复标题,回复内容)
即非关键字段部分函数依赖于候选关键字段，很明显，这个设计会导致大量的数据冗余和操作异常。
我们将数据库表分解为（带下划线的为关键字）：
（1） 用户信息：用户名，email，主页，电话，联系地址
（2） 帖子信息：发帖ID，标题，内容
（3） 回复信息：回复ID，标题，内容
（4） 发贴：用户名，发帖ID
（5） 回复：发帖ID，回复ID
这样的设计是满足第1、2、3范式和BCNF范式要求的，但是这样的设计是不是最好的呢？
不一定。
观察可知，第4项"发帖"中的"用户名"和"发帖ID"之间是1：N的关系，因此我们可以把"发帖"合并到第2项的"帖子信息"中；第5项"回复"中的"发帖ID"和"回复ID"之间也是1：N的关系，因此我们可以把"回复"合并到第3项的"回复信息"中。这样可以一定量地减少数据冗余，新的设计为：
（1） 用户信息：用户名，email，主页，电话，联系地址
（2） 帖子信息：用户名，发帖ID，标题，内容
（3） 回复信息：发帖ID，回复ID，标题，内容
数据库表1显然满足所有范式的要求；
数据库表2中存在非关键字段"标题"、"内容"对关键字段"发帖ID"的部分函数依赖，即不满足第二范式的要求，但是这一设计并不会导致数据冗余和操作异常；
数据库表3中也存在非关键字段"标题"、"内容"对关键字段"回复ID"的部分函数依赖，也不满足第二范式的要求，但是与数据库表2相似，这一设计也不会导致数据冗余和操作异常。
由此可以看出，并不一定要强行满足范式的要求，对于1：N关系，当1的一边合并到N的那边后，N的那边就不再满足第二范式了，但是这种设计反而比较好！
对于M：N的关系，不能将M一边或N一边合并到另一边去，这样会导致不符合范式要求，同时导致操作异常和数据冗余。
对于1：1的关系，我们可以将左边的1或者右边的1合并到另一边去，设计导致不符合范式要求，但是并不会导致操作异常和数据冗余。
结论
满足范式要求的数据库设计是结构清晰的，同时可避免数据冗余和操作异常。这并意味着不符合范式要求的设计一定是错误的，在数据库表中存在1：1或1：N关系这种较特殊的情况下，合并导致的不符合范式要求反而是合理的。
在我们设计数据库的时候，一定要时刻考虑范式的要求。
posted @
2008-11-21 11:09 Benson 阅读(348) |
评论 (0) |
编辑 收藏