每个编写程序的人也许都有过这样的体验：对编写的程序作了一些修改，几天以后，我们可能发现上次的修改导致了其它的矛盾，甚至编译不能通过，但这时我们却很难找到自己刚在哪里作了改动。一般说来，我们总是希望自己完整的记录下一个程序开发的过程，记录下这个程序的每一点改进和调整。或许我们可以用备份的方法来解决这个问题，于是我们建立一个backup的目录，定期或不定期的将自己的源程序打包放进去，直到某一天整个硬盘都被这些文件撑满。这当然有些夸张，但这种机制带给我们的不方便是显而易见的。更进一步，现在一个软件产品的开发，一个人单枪匹马很难完成。可能是包含几个、几十个乃至上百个程序员协作开发，这时的源代码又该如何管理？解决问题的方法就是使用CVS。
　　CVS - Concurrent Versions System(并发版本管理系统)是一个版本控制管理系统，它是目前最为广泛使用的一个系统。从gftp到gtk到KDE，你几乎可以在每一个你熟悉的自由软件的源码里看到它的踪迹(下面我们会知道，它的踪迹指一个称为cvs的子目录)。同样，你也可以在几乎每一个Linux的发行版本里看到CVS系统。可以说，如果失去了CVS，现有的许多多人协作、自由开发的软件都会在一定程度上放慢自己发展的步伐。 　　CVS到底有哪些功能，使得它有如此强大的魅力呢？
　　1.CVS能做什么？
　　　如上所说，CVS首先是一个版本管理系统，它可以保留软件开发过程中的每一个版本的信息，包括谁、在何时、作了什么样的修改以及为什么作这样的修改等。这个功能和以前流行于Linux和Unix的版本管理系统RCS(Revision Control System)和SCCS(Source Code Control System)很象。但CVS的功能远非仅此。它的最大的特点是它的并发性，即它支持分布式项目的开发。在互联网席卷一切的今天，这个功能太为重要了。小到一个办公室内部开发一个OA系统，大到KDE小组利用互联网开发新版本的KDE，CVS都可以一展身手。一个程序员开发出了自己负责模块的新版本后，迅速的通过CVS让开发组的每一个成员都分享自己的最新成果。甚至，CVS通过特定的机制允许多个程序员同时修改同一个源程序文件。
　　另外CVS增强的目录结构以及对二进制文件良好的处理，都使得它远远优于其它的版本管理系统。最后，必须一提的是CVS是基于RCS开发而成的。
　　2.如何得到CVS?
　　　CVS在几乎包含在所有的Linux发布版本中，如RedHat、Turbo Linux、Slackware以及国产的红旗、Xteam Linux等。你可以试着敲一下cvs命令，大多数情况下都会出现以Usage: cvs开头的一堆信息，提示你如何使用cvs，这意味着在你的机器上早已有了CVS，只是遗憾的是它一直未被你发现和利用。运气不好的话，你会看到形如cvs: Command not found.的提示，这意味着你的机器没有安装CVS。这时你有两种选择。一是找到你的Linux安装盘，从那里安装CVS。例如在使用RPM方式安装的Linux(上面介绍的几个发布版本中似乎除了Slackware，其他都是)发布版本中，找到cvs***.rpm，用rpm命令进行安装。第二种方式是到一些站点cvs的源代码，然后遵循里面附带的指导进行安装，需要的读者请访问站点www.cyclic.com/或者http://www.loria.fr/~molli/cvs-index.html。
　　3.CVS的基本使用方法
　　　在这一节里，我们来学习掌握CVS的一些基本使用方法。现在我们假定已经安装好了CVS，并且我们打算用它来管理自己正在开发的一个软件，软件名叫netants，它存放在硬盘上一个叫做netants的目录里，目前里面有了文件netants.c、netants.h、http.c、http.h和Makefile。我们并没有和它人协作开发这个软件，也没有利用Internet或者Intranet来开发这个软件。或许，它只是自己的一个业余作品，试图写出一个比Windows下的网络蚂蚁更好的下载工具出来。
　　3.1初始化CVS　
　　我们首先要使用的命令是cvs init，这个命令用来初始化CVS系统。正如我们所看到的，所有的CVS命令都以cvs开头，然后在后面紧跟命令、参数和一些选项。初始化CVS系统主要是为了创建一个为CVS所使用的源码储存库(repository)。创建的时候，需要指定在那个目录下创建这个源码储存库。有两种方法来指定目录。一是利用"-d "选项来指定，例如：-d /usr/local/cvsroot。另一种更方便的方法是在shell里设定一个名叫CVSROOT的环境变量。使用csh或者tcsh的用户可以使用命令setenv来设定，在文件.csh rc或者文件.tcshrc里添加入下的一行：　setenv CVSROOT /usr/local/cvsroot　使用sh或者bash的用户需要在文件.profile或者文件.bashrc里添加如下两行：　CVSROOT=/usr/local/cvsroot　export CVSROOT　设置了环境变量CVSROOT后，我们运行命令cvs init，CVS将在指定的目录下面建立自己所需要的一些文件，以后我们使用CVS管理的任何项目，都会被CVS储存在这个目录之下。不过千万要注意的是：永远不要去试图修改这个目录下的文件。这个目录是由CVS自己进行管理的，轻率的改动可能会导致你丢失你部分或全部的交由CVS管理的源代码或其他资源。
　　3.2导入项目到CVS中去
　　初始化结束以后，我们就要真正开始利用CVS来管理自己的程序网络蚂蚁了。第一步，我们将这个项目交由CVS管理。使用如下的CVS的import命令，将源程序导入到CVS的源码储存库中去：　cd netants　cvs import -m "start my project: Netants" netants yoyo start　这个命令看起来有些复杂，需要解释一下。import是cvs的导入命令，默认状况下，它循环的将当前目录下的所有文件(包括子目录)导入到源码库(即CVSROOT指定的目录)里去。-m "start my project: Netants"告诉CVS你对这一步操作的说明。这是CVS强制要求的，如果你没有使用这种-m "字符串"的选项，CVS将会弹出一个文本编辑器(如果自己不特别指定的话，在Linux下一般是vi，而在Windows下则是Notepad)，让你输入一些说明信息它才罢休。netants是这个项目被CVS存储时的路径名，即CVS将在创建一个$CVSROOT/netants的目录，并在此目录下存放此项目的文件，当然，它不是原封不动的存储，CVS会做一番处理。最后两个字符串设定了两个标记(tag)，现在并没有什么用处，但它们同样是CVS指定必需的，所以我们添上这两个参数。执行此命令时，CVS自动将所有的文件版本设为1.1，这是它所认为的最低版本。以下为执行上述命令后的显示信息：N netants/netants.c N netants/http.c N netants/http.h N netants/netants.h N netants/Makefile No conflicts created by this import N表示New，CVS成功的加载了这些文件，并没有发现冲突。　上面的命令稍长了一些，而且显得有些繁琐，相信我，CVS不总是这样的，这点"繁琐"相对它给我们带来的便利是完全可以忽略不计的。
　　3.3从CVS中导出项目　
　　好了，我们把自己的netants的项目交给了CVS去管理，现在，我们完全可以删除原有的存储我们代码的netants目录(当然，安全起见，你或许应该再做一次备份，并希望是最后一次)。我们要进行开发工作了，建一个目录，叫什么呢，就叫worktmp吧。我们进到此目录下，执行命令cvs checkout netants，我们将会看到如下的信息：cvs checkout: Updating netants U netants/Makefile U netants/http.c U netants/http.h U netants/netants.c U netants/netants.h　CVS在当前目录下建立一个叫做netants的目录，我们原先的代码文件都在这个目录下出现了，而且还多了一个名为CVS的目录。目录CVS下面存放的是一些文本文件，记录了CVSROOT的位置、此项目对应源码库中那个目录等一些信息。
　　3.4保存修改到CVS中
　　　现在，我们开始艰苦卓越的编程工作。经过数十分钟、数小时乃至数天的工作，我们对原有的代码做了较大的修改，现在要告一段落了。我们将修改的内容提交给CVS，于是，我们需要执行命令　cvs commit -m "Made some useful changes on some files"　这时，我们将会看到CVS给出一些提示信息，它扫描并比较此目录下的现有文件和它在源码库中保存的原有文件，做了修改的文件将被更新，并且有了新的版本号：1.2。-m参数如同前面所说，是为了不想它启动一个文本编辑器来让自己输入。如果我们仅是修改了其中一两个文件，我们可以在上面的命令的最后附上文件名，这样CVS只会比较、更新指定的文件。注意的是，和自己做备份不同，CVS只是保存了不同版本之间的差异，并没有完整的保存各个版本。现在，你是不是觉得CVS有点用处了。
　　3.5添加文件到项目中
　　有一天，我们开始考虑给我们的网络蚂蚁加上从ftp站点下载文件的功能，于是，我们需要在原有的项目里添加两个文件：ftp.c和ftp.h。首先，我们在工作目录下建立并编辑、修改、生成了这两个文件，然后我们使用命令add命令来添加。　cvs add ftp.c ftp.h　此时，文件并没有真正的被添加，只是相当于"注册"了一下，要使这个过程生效，我们仍然需要使用commit命令：　cvs commit ftp.c ftp.h -m "Add two files: ftp.c and ftp.h"　此时，CVS将把这两个文件添加到项目中去，他们的版本均为初始的1.1。　　3.6从项目中删除文件
　　除了添加以外，我们有的时候可能需要删除某个文件，例如我们发现文件netants.h其实没有什么用。于是，我们执行下面几个命令来完成删除工作：　rm netants.h　cvs remove netants.h　cvs commit netants.h -m "Delete a file."　要注意的是，CVS只是删除了当前版本的netants.h，它以前的版本依然存在，除非它恰好仅有1.1版本。
　　3.7设定特定版本号　
　　经过一段时间的工作，程序已经初具规模，形成了较稳定的版本。这个时候，netants.c可能已经是5.4版本，而http.c可能是3.5版本，而我们希望将当前的代码作一个版本发布。此时，我们需要使用的是tag命令。这个命令赋予指定的一个或多个文件一个给定的文本形式的版本号。版本号必须以字母开始，可以包含数字、下划线和连接符号(-)。我们想给当前项目的所有文件赋予相同的版本号时，可以不指定文件或路径参数，CVS默认选择当前目录下所有在CVS中注册的文件(循环进子目录)。下面既是一个例子：　键入命令：cvs tag release0-1　提示信息：　　　　cvs tag: Tagging .　　　　T Makefile　　　　T ftp.c　　　　T ftp.h　　　　T http.c　　　　T http.h　　　　T netants.c　这样当前版本的所有文件都有了一个叫做release0-1的版本代号。当我们需要这个版本的时候，我们使用-r (版本代号)参数来得到指定的版本。例如命令：　cvs checkout -r release0-1 netants　将在当前目录下建立netants目录，并导出所有版本代号为release0-1的文件。
　　3.8更新当前工作目录中的文件
　　　这里使用的命令为update，它将比较指定的在CVS源码库中的文件和当前目录下的文件，如果CVS源码库中有更高版本的源文件，则更新当前目录下的文件。这个功能主要是多人协作开发项目时使用的，让你及时分享同伴的工作成果。但它另外一个重要的用途，同样适用于单人开发的项目。这个用途需要使用-j参数，我们看下面的例子：　cvs update -j 1.5 -j 1.3 netants.c　这个命令的功能是，在当前目录的netants.c文件中，忽略从版本1.3到版本1.5所作的修改。毫无疑问，对程序员来说，这是一个非常重要的功能。因为在某个阶段我们对程序所作的修改在现在可能会被视为是无效乃至错误的，这个功能很好的解决了这个问题。　在更新的过程中，CVS执行一个自动合并的过程。例如我们的工作目录中的netants.c文件版本是2.1，并且我们已经对此文件作了一番修改，而CVS源码库中的是版本2.2，此时我们执行update命令时，CVS并不是简单的将版本2.2覆盖版本2.1，而是试图将自版本2.1到版本2.2的修改添加到当前目录中的文件中去，如果它和我们刚刚所作的修改有冲突，则CVS会以字符串">>>>"表示由冲突发生，期待用户去修改。CVS拒绝接受包含有上述特定字符串的文件。下面即是一个冲突的例子：netants.c:版本号2.2，保存在CVS中……getPartFile( ); showFinished(); return(A); }……
　　netants:版本号2.1经过我们的修改……getPartFile( ); return(B); }……我们执行命令cvs update netants.c后，将会包含如下内容的新的netants.c：
　　……getPartFile( ); showFinished(); >>>>>> 2.2 }……　除非我们做出修改并删去">>>>>>"，否则在执行cvs commit的时候，netants.c将不会更新原有的2.2版本。
　　4.CVS的其他功能
　　CVS当然远不止上面所说的这些内容，这些仅是CVS的基本功能，CVS还有许多重要的功能，如上面所说的网络工作方式、支持二进制文件等。下面我们对这些功能作简单的说明。
　　4.1 CVS的网络工作方式　
　　CVS的网络功能采用client-server结构，两地均需安装CVS。CVS采用rsh方式或者口令校验方式进行工作。对client端，同前面讲过的设置环境变量CVSROOT一样，用户需要设置新的环境变量CVS_SERVER，指明CVS在server上的路径，例如：/usr/local/cvsroot1。CVS的-d参数指定路径名，它后面可以用：(local或server或ext)：来指明是在本地还是在异地服务器上，默认当然是在本地，正如我们在初始化CVS一节所使用的那样。下面的命令假定我们的CVS服务器为cvs.rdcps.ac.cn，用户名为crazyyao，CVS源码库在服务器的/usr/local/cvsroot1目录下，我们的工作项目还是netants，我们用rsh方式导出项目文件：　cvs -d : server : crazyyao@cvs.rdcps.ac.cn :/usr/local/cvsroot1 checkout netants　采用口令校验方式时，需要对修改系统文件/etc/inetd.conf，以便使inetd知道如何分配、处理CVS Server的请求和响应。CVS会在源码库所在的目录中创建一个名为passwd的口令文件，对用户进行校验。使用口令校验时，CVS支持匿名登陆，而且CVS项目超级用户可以设置项目中文件的存取权限。　关于如何配置CVS使之工作在网络方式下的详细信息请参考CVS的文档。
　　4.2 CVS的分支和融合功能
　　　CVS增强的目录工作方式使得CVS提供分支和融合功能。有的时候，当项目进展到一定程度时，可能需要暂时中断，去做另外一些修改和发展。例如，我们的软件原有版本为1.0，并已提交用户使用，现在正在开发2.0。某一天，1.0的用户发现了一个较大的bug或者需要添加某个短小的功能，这时我们不能让用户去期待2.0版本，又必须给用户满意的答复，比较理想的解决方式是把现在的工作先放到一边，另开一个分支，去满足用户的需要。当此分支完成后，程序源还可以使用CVS的融合功能将这一部分修改添加到我们开发2.0版本的主工作进程中去。　创建分支可以使用tag -b命令。例如下面的命令　　　cvs tag -b netants-1-0-patch　在当前的工作目录的基础上创建一个叫做netant-1-0-patch的分支。　融合的命令参数是-j，我们在前面已经提及它了。
　　4.3 CVS处理二进制文件的功能　
　　CVS可以保存二进制文件，但和文本文件相比，它的许多功能丧失了。对于文本文件，CVS可以辨别出文件的任何一点改动，但对于二进制文件它无能为力。但是，CVS可以区分出文件作了改动，并会提示用户自己修改、保存。与文本文件不同，CVS保存二进制文件每个版本的完整信息。在操作二进制文件时，需要添加参数-KB，以便告诉CVS不把它当作文本文件看待。
　　4.4 CVS比较文件的功能　
　　执行的命令为diff，这个功能和shell下的diff功能基本一样。例如下面的命令比较CVS源码库中的最新的netants.c文件和当前目录下netants.c文件有什么不同：　cvs diff netatns.c
　　5.结束语
　　通过上面的介绍，希望能激起大家使用CVS的兴趣，并掌握使用CVS的一些基本方法。碰到困难时，别忘了翻阅CVS附带的手册，不过，它有厚厚的172页。希望CVS能加速你的软件开发。

2004-11-24微软技术博客

作者： wjk.net(转载)

一个成功的管理系统，是由：[50% 的业务 + 50% 的软件] 所组成，而 50% 的成功软件又有 [25% 的数据库 + 25%的程序] 所组成，数据库设计的好坏是一个关键。如果把企业的数据比做生命 所必需的血液，那么数据库的设计就是应用中最重要的一部分 。有关数据库设计的材料汗牛充栋，大学学位课程里也有专门的讲述 。不过，就如我们反复强调的那样，再好的老师也比不过经验的教诲 。所以我归纳历年来所走的弯路及体会，并在网上找了些对数据库设 计颇有造诣的专业人士给大家传授一些设计数据库的技巧和经验 。精选了其中的60 个最佳技巧，并把这些技巧编写成了本文，为了方便索引其内容划分 为 5 个部分：

第 1 部分 - 设计数据库之前

这一部分罗列了 12 个基本技巧，包括命名规范和明确业务需求等。

第 2 部分 - 设计数据库表

总共 24 个指南性技巧，涵盖表内字段设计以及应该避免的常见问题等。

第 3 部分 - 选择键

怎么选择键呢？这里有 10 个技巧专门涉及系统生成的主键的正确用法，还有何 时以及如何索引字段以获得最佳性能等。

第 4 部分 - 保证数据完整性

讨论如何保持数据库的清晰和健壮，如何把有害数据降低到最小程度 。

第 5 部分 - 各种小技巧

不包括在以上 4 个部分中的其他技巧，五花八门，有了它们希望你的数据库开发工作 会更轻松一些。

第 1 部分 - 设计数据库之前

考察现有环境

在设计一个新数据库时，你不但应该仔细研究业务需求而且还要考察 现有的系统。大多数数据库项目都不是从头开始建立的；通常 ，机构内总会存在用来满足特定需求的现有系统（可能没有实现自动 计算）。显然，现有系统并不完美，否则你就不必再建立新系统了 。但是对旧系统的研究可以让你发现一些可能会忽略的细微问题 。一般来说，考察现有系统对你绝对有好处。

定义标准的对象命名规范

一定要定义数据库对象的命名规范。对数据库表来说 ，从项目一开始就要确定表名是采用复数还是单数形式 。此外还要给表的别名定义简单规则（比方说，如果表名是一个单词 ，别名就取单词的前4 个字母；如果表名是两个单词，就各取两个单词的前两个字母组成 4 个字母长的别名；如果表的名字由 3个单词组成，你不妨从头两个单词中各取一个然后从最后一个单词中 再取出两个字母，结果还是组成 4字母长的别名，其余依次类推）对工作用表来说，表名可以加上前缀 WORK_后面附上采用该表的应用程序的名字。表内的列[字段 ]要针对键采用一整套设计规则。比如，如果键是数字类型 ，你可以用 _N作为后缀；如果是字符类型则可以采用 _C后缀。对列[字段]名应该采用标准的前缀和后缀。再如 ，假如你的表里有好多"money"字段，你不妨给每个列[字段 ]增加一个 _M后缀。还有，日期列[字段]最好以 D_ 作为名字打头。

检查表名、报表名和查询名之间的命名规范。你可能会很快就被这些 不同的数据库要素的名称搞糊涂了。假如你坚持统一地命名这些数据 库的不同组成部分，至少你应该在这些对象名字的开头用Table、Query 或者 Report 等前缀加以区别。

如果采用了 Microsoft Access，你可以用 qry、rpt、tbl 和 mod 等符号来标识对象（比如tbl_Employees）。我在和 SQL Server 打交道的时候还用过 tbl 来索引表，但我用 sp_company （现在用 sp_feft_）标识存储过程，因为在有的时候如果我发现了更 好的处理办法往往会保存好几个拷贝。我在实现 SQL Server 2000 时用udf_ （或者类似的标记）标识我编写的函数。

工欲善其事, 必先利其器

采用理想的数据库设计工具，比如：SyBase 公司的 PowerDesign，她支持 PB、VB、Delphe 等语言，通过 ODBC可以连接市面上流行的 30 多个数据库，包括 dBase、FoxPro、VFP、SQL Server 等，今后有机会我将着重介绍PowerDesign 的使用。

获取数据模式资源手册

正在寻求示例模式的人可以阅读《数据模式资源手册》一书，该书由 Len Silverston、W. H. Inmon 和 Kent Graziano 编写，是一本值得拥有的最佳数据建模图书。该书包括的章节涵盖多 种数据领域，比如人员、机构和工作效能等。其他的你还可以参考： [1]萨师煊王珊著数据库系统概论(第二版)高等教育出版社 1991、[2][美] Steven M.Bobrowski 著 Oracle 7
与客户／服务器计算技术从入门到精通刘建元等译电子工业出版社，1996、[3]周中元信息系统建模方法(下)电子与信息化1999年第3期，1999畅想未来，但不可忘了过去的教训我发现询问用户如何看待未来需求变化非常有用。这样做可以达到两 个目的：首先，你可以清楚地了解应用设计在哪个地方应该更具灵活 性以及如何避免性能瓶颈；其次，你知道发生事先没有确定的需求变 更时用户将和你一样感到吃惊。

一定要记住过去的经验教训！我们开发人员还应该通过分享自己的体 会和经验互相帮助。即使用户认为他们再也不需要什么支持了 ，我们也应该对他们进行这方面的教育，我们都曾经面临过这样的时 刻"当初要是这么做了该多好.."。

在物理实践之前进行逻辑设计

在深入物理设计之前要先进行逻辑设计。随着大量的 CASE工具不断涌现出来，你的设计也可以达到相当高的逻辑水准 ，你通常可以从整体上更好地了解数据库设计所需要的方方面面。

了解你的业务

在你百分百地确定系统从客户角度满足其需求之前不要在你的 ER（实体关系）模式中加入哪怕一个数据表（怎么，你还没有模式 ？那请你参看技巧9）。了解你的企业业务可以在以后的开发阶段节约大量的时间 。一旦你明确了业务需求，你就可以自己做出许多决策了。

一旦你认为你已经明确了业务内容，你最好同客户进行一次系统的交 流。采用客户的术语并且向他们解释你所想到的和你所听到的 。同时还应该用可能、将会和必须等词汇表达出系统的关系基数 。这样你就可以让你的客户纠正你自己的理解然后做好下一步的ER 设计。

创建数据字典和 ER 图表

一定要花点时间创建 ER 图表和数据字典。其中至少应该包含每个字段的数据类型和在每个表 内的主外键。创建 ER
图表和数据字典确实有点费时但对其他开发人员要了解整个设计却是 完全必要的。越早创建越能有助于避免今后面临的可能混乱 ，从而可以让任何了解数据库的人都明确如何从数据库中获得数据。

有一份诸如 ER 图表等最新文档其重要性如何强调都不过分，这对表明表之间关系很 有用，而数据字典则说明了每个字段的用途以及任何可能存在的别名 。对SQL 表达式的文档化来说这是完全必要的。

创建模式

一张图表胜过千言万语：开发人员不仅要阅读和实现它 ，而且还要用它来帮助自己和用户对话。模式有助于提高协作效能 ，这样在先期的数据库设计中几乎不可能出现大的问题 。模式不必弄的很复杂；甚至可以简单到手写在一张纸上就可以了 。只是要保证其上的逻辑关系今后能产生效益。

从输入输出下手

在定义数据库表和字段需求（输入）时，首先应检查现有的或者已经 设计出的报表、查询和视图（输出）以决定为了支持这些输出哪些是 必要的表和字段。举个简单的例子：假如客户需要一个报表按照邮政 编码排序、分段和求和，你要保证其中包括了单独的邮政编码字段而 不要把邮政编码糅进地址字段里。

报表技巧

要了解用户通常是如何报告数据的：批处理还是在线提交报表 ？时间间隔是每天、每周、每月、每个季度还是每年 ？如果需要的话还可以考虑创建总结表。系统生成的主键在报表中很 难管理。用户在具有系统生成主键的表内用副键进行检索往往会返回 许多重复数据。这样的检索性能比较低而且容易引起混乱。

理解客户需求

看起来这应该是显而易见的事，但需求就是来自客户 （这里要从内部和外部客户的角度考虑）。不要依赖用户写下来的需 求，真正的需求在客户的脑袋里。你要让客户解释其需求 ，而且随着开发的继续，还要经常询问客户保证其需求仍然在开发的 目的之中。一个不变的真理是："只有我看见了我才知道我想要的是 什么"必然会导致大量的返工，因为数据库没有达到客户从来没有写 下来的需求标准。而更糟的是你对他们需求的解释只属于你自己 ，而且可能是完全错误的。

第 2 部分 - 设计表和字段

检查各种变化

我在设计数据库的时候会考虑到哪些数据字段将来可能会发生变更 。比方说，姓氏就是如此（注意是西方人的姓氏，比如女性结婚后从 夫姓等）。所以，在建立系统存储客户信息时，我倾向于在单独的一 个数据表里存储姓氏字段，而且还附加起始日和终止日等字段 ，这样就可以跟踪这一数据条目的变化。

采用有意义的字段名

有一回我参加开发过一个项目，其中有从其他程序员那里继承的程序 ，那个程序员喜欢用屏幕上显示数据指示用语命名字段，这也不赖 ，但不幸的是，她还喜欢用一些奇怪的命名法，其命名采用了匈牙利 命名和控制序号的组合形式，比如cbo1、txt2、txt2_b 等等。
除非你在使用只面向你的缩写字段名的系统，否则请尽可能地把字段 描述的清楚些。当然，也别做过头了，比如Customer_Shipping_Address _Street_Line_1，虽然很富有说明性 ，但没人愿意键入这么长的名字，具体尺度就在你的把握中。
采用前缀命名。如果多个表里有好多同一类型的字段（比如 FirstName），你不妨用特定表的前缀（比如 CusLastName）来帮助你标识字段。

时效性数据应包括"最近更新日期/时间"字段。时间标记对查找数 据问题的原因、按日期重新处理/重载数据和清除旧数据特别有用。
标准化和数据驱动数据的标准化不仅方便了自己而且也方便了其他人。比方说 ，假如你的用户界面要访问外部数据源（文件、XML
文档、其他数据库等），你不妨把相应的连接和路径信息存储在用户 界面支持表里。还有，如果用户界面执行工作流之类的任务 （发送邮件、打印信笺、修改记录状态等），那么产生工作流的数据 也可以存放在数据库里。预先安排总需要付出努力，但如果这些过程 采用数据驱动而非硬编码的方式，那么策略变更和维护都会方便得多 。事实上，如果过程是数据驱动的，你就可以把相当大的责任推给用 户，由用户来维护自己的工作流过程。

标准化不能过头

对那些不熟悉标准化一词（normalization）的人而言 ，标准化可以保证表内的字段都是最基础的要素，而这一措施有助于 消除数据库中的数据冗余。标准化有好几种形式，但Third Normal Form（3NF）通常被认为在性能、扩展性和数据完整性方面达 到了最好平衡。简单来说，3NF 规定：
* 表内的每一个值都只能被表达一次。
* 表内的每一行都应该被唯一的标识（有唯一键）。
* 表内不应该存储依赖于其他键的非键信息。
遵守 3NF 标准的数据库具有以下特点：有一组表专门存放通过键连接起来的关 联数据。比方说，某个存放客户及其有关定单的 3NF
数据库就可能有两个表：Customer 和 Order。Order 表不包含定单关联客户的任何信息，但表内会存放一个键值 ，该键指向Customer 表里包含该客户信息的那一行。
更高层次的标准化也有，但更标准是否就一定更好呢？答案是不一定 。事实上，对某些项目来说，甚至就连 3NF 都可能给数据库引入太高的复杂性。

为了效率的缘故，对表不进行标准化有时也是必要的 ，这样的例子很多。曾经有个开发餐饮分析软件的活就是用非标准化 表把查询时间从平均 40秒降低到了两秒左右。虽然我不得不这么做，但我绝不把数据表的非 标准化当作当然的设计理念。而具体的操作不过是一种派生 。所以如果表出了问题重新产生非标准化的表是完全可能的。

Microsoft Visual FoxPro 报表技巧

如果你正在使用 Microsoft Visual FoxPro，你可以用对用户友好的字段名来代替编号的名称 ：比如用 Customer Name 代替 txtCNaM。这样，当你用向导程序 [Wizards，台湾人称为'精灵'] 创建表单和报表时，其名字会让那些不是程序员的人更容易阅读。

不活跃或者不采用的指示符

增加一个字段表示所在记录是否在业务中不再活跃挺有用的 。不管是客户、员工还是其他什么人，这样做都能有助于再运行查询 的时候过滤活跃或者不活跃状态。同时还消除了新用户在采用数据时 所面临的一些问题，比如，某些记录可能不再为他们所用 ，再删除的时候可以起到一定的防范作用。

使用角色实体定义属于某类别的列[字段]

在需要对属于特定类别或者具有特定角色的事物做定义时 ，可以用角色实体来创建特定的时间关联关系，从而可以实现自我文 档化。
这里的含义不是让 PERSON 实体带有 Title 字段，而是说，为什么不用 PERSON 实体和 PERSON_TYPE实体来描述人员呢？比方说，当 John Smith, Engineer 提升为 John Smith, Director 乃至最后爬到John Smith, CIO 的高位，而所有你要做的不过是改变两个表 PERSON 和 PERSON_TYPE之间关系的键值，同时增加一个日期/时间字段来知道变化是何时发 生的。这样，你的 PERSON_TYPE 表就包含了所有 PERSON的可能类型，比如 Associate、Engineer、Director 、CIO 或者 CEO 等。
还有个替代办法就是改变 PERSON 记录来反映新头衔的变化，不过这样一来在时间上无法跟踪个人所处 位置的具体时间。

采用常用实体命名机构数据

组织数据的最简单办法就是采用常用名字，比如：PERSON 、ORGANIZATION、ADDRESS 和 PHONE等等。当你把这些常用的一般名字组合起来或者创建特定的相应副实 体时，你就得到了自己用的特殊版本。开始的时候采用一般术语的主 要原因在于所有的具体用户都能对抽象事物具体化。
有了这些抽象表示，你就可以在第 2 级标识中采用自己的特殊名称，比如，PERSON 可能是Employee、Spouse、Patient、Client 、Customer、Vendor 或者 Teacher等。同样的，ORGANIZATION 也可能是
MyCompany、MyDepartment、Competi tor、Hospital、Warehouse、Governm ent 等。最后ADDRESS 可以具体为 Site、Location、Home、Work、Client 、Vendor、Corporate 和FieldOffice 等。
采用一般抽象术语来标识"事物"的类别可以让你在关联数据以满足 业务要求方面获得巨大的灵活性，同时这样做还可以显著降低数据存 储所需的冗余量。

用户来自世界各地

在设计用到网络或者具有其他国际特性的数据库时，一定要记住大多 数国家都有不同的字段格式，比如邮政编码等，有些国家 ，比如新西兰就没有邮政编码一说。

数据重复需要采用分立的数据表

如果你发现自己在重复输入数据，请创建新表和新的关系。
每个表中都应该添加的 3 个有用的字段
* dRecordCreationDate，在 VB 下默认是 Now()，而在 SQL Server 下默认为 GETDATE()
* sRecordCreator，在 SQL Server 下默认为 NOT NULL DEFAULT USER
* nRecordVersion，记录的版本标记；有助于准确说明 记录中出现 null 数据或者丢失数据的原因
对地址和电话采用多个字段
描述街道地址就短短一行记录是不够的。Address _Line1、Address_Line2 和 Address_Line3
可以提供更大的灵活性。还有，电话号码和邮件地址最好拥有自己的 数据表，其间具有自身的类型和标记类别。

过分标准化可要小心，这样做可能会导致性能上出现问题 。虽然地址和电话表分离通常可以达到最佳状态，但是如果需要经常 访问这类信息，或许在其父表中存放"首选"信息（比如
Customer 等）更为妥当些。非标准化和加速访问之间的妥协是有一定意义的。

使用多个名称字段

我觉得很吃惊，许多人在数据库里就给 name留一个字段。我觉得只有刚入门的开发人员才会这么做 ，但实际上网上这种做法非常普遍。我建议应该把姓氏和名字当作两 个字段来处理，然后在查询的时候再把他们组合起来。

我最常用的是在同一表中创建一个计算列[字段]，通过它可以自动 地连接标准化后的字段，这样数据变动的时候它也跟着变。不过 ，这样做在采用建模软件时得很机灵才行。总之，采用连接字段的方 式可以有效的隔离用户应用和开发人员界面。
提防大小写混用的对象名和特殊字符过去最令我恼火的事情之一就是数据库里有大小写混用的对象名 ，比如 CustomerData。这一问题从 Access 到 Oracle数据库都存在。我不喜欢采用这种大小写混用的对象命名方法 ，结果还不得不手工修改名字。想想看，这种数据库 /应用程序能混到采用更强大数据库的那一天吗？采用全部大写而且 包含下划符的名字具有更好的可读性（CUSTOMER_DATA ），绝对不要在对象名的字符之间留空格。

小心保留词

要保证你的字段名没有和保留词、数据库系统或者常用访问方法冲突 ，比如，最近我编写的一个 ODBC 连接程序里有个表，其中就用了 DESC作为说明字段名。后果可想而知！DESC 是 DESCENDING 缩写后的保留词。表里的一个 SELECT *语句倒是能用，但我得到的却是一大堆毫无用处的信息。

保持字段名和类型的一致性

在命名字段并为其指定数据类型的时候一定要保证一致性 。假如字段在某个表中叫做"agreement_number" ，你就别在另一个表里把名字改成"ref1"。假如数据类型在一 个表里是整数，那在另一个表里可就别变成字符型了。记住 ，你干完自己的活了，其他人还要用你的数据库呢。

仔细选择数字类型

在 SQL 中使用 smallint 和 tinyint 类型要特别小心，比如，假如你想看看月销售总额，你的总额字段类 型是smallint，那么，如果总额超过了 $32,767 你就不能进行计算操作了。

删除标记

在表中包含一个"删除标记"字段，这样就可以把行标记为删除 。在关系数据库里不要单独删除某一行；最好采用清除数据程序而且 要仔细维护索引整体性。

避免使用触发器

触发器的功能通常可以用其他方式实现。在调试程序时触发器可能成 为干扰。假如你确实需要采用触发器，你最好集中对它文档化。
包含版本机制建议你在数据库中引入版本控制机制来确定使用中的数据库的版本 。无论如何你都要实现这一要求。时间一长，用户的需求总是会改变 的。最终可能会要求修改数据库结构。虽然你可以通过检查新字段或 者索引来确定数据库结构的版本，但我发现把版本信息直接存放到数 据库中不更为方便吗？

给文本字段留足余量

ID 类型的文本字段，比如客户 ID或定单号等等都应该设置得比一般想象更大，因为时间不长你多半就 会因为要添加额外的字符而难堪不已。比方说，假设你的客户 ID 为 10位数长。那你应该把数据库表字段的长度设为 12 或者 13 个字符长。这算浪费空间吗？是有一点，但也没你想象的那么多 ：一个字段加长 3个字符在有 1 百万条记录，再加上一点索引的情况下才不过让整个数据库多占据 3MB的空间。但这额外占据的空间却无需将来重构整个数据库就可以实现 数据库规模的增长了。身份证的号码从 15 位变成 18
位就是最好和最惨痛的例子。

列[字段]命名技巧

我们发现，假如你给每个表的列[字段]名都采用统一的前缀 ，那么在编写 SQL表达式的时候会得到大大的简化。这样做也确实有缺点 ，比如破坏了自动表连接工具的作用，后者把公共列[字段 ]名同某些数据库联系起来，不过就连这些工具有时不也连接错误嘛 。举个简单的例子，假设有两个表：
Customer 和 Order。Customer 表的前缀是cu_，所以该表内的子段名如下：cu_name_id、cu _surname、cu_initials 和cu_address 等。Order表的前缀是 or_，所以子段名是：
or_order_id、or_cust_name_id、or _quantity 和 or_denoscription 等。
这样从数据库中选出全部数据的 SQL 语句可以写成如下所示：
Select * From Customer, Order Where cu_surname = "MYNAME" ;
and cu_name_id = or_cust_name_id and or_quantity = 1
在没有这些前缀的情况下则写成这个样子（用别名来区分）：
Select * From Customer, Order Where Customer.surname = "MYNAME" ;
and Customer.name_id = Order.cust_name_id and Order.quantity = 1
第 1 个 SQL 语句没少键入多少字符。但如果查询涉及到 5 个表乃至更多的列[字段]你就知道这个技巧多有用了。

第 3 部分 - 选择键和索引

数据采掘要预先计划

我所在的某一客户部门一度要处理 8万多份联系方式，同时填写每个客户的必要数据（这绝对不是小活） 。我从中还要确定出一组客户作为市场目标。当我从最开始设计表和 字段的时候，我试图不在主索引里增加太多的字段以便加快数据库的 运行速度。然后我意识到特定的组查询和信息采掘既不准确速度也不 快。结果只好在主索引中重建而且合并了数据字段。我发现有一个指 示计划相当关键——当我想创建系统类型查找时为什么要采用号码作 为主索引字段呢？我可以用传真号码进行检索，但是它几乎就象系统 类型一样对我来说并不重要。采用后者作为主字段，数据库更新后重 新索引和检索就快多了。

可操作数据仓库（ODS）和数据仓库（DW）这两种环境下的数据 索引是有差别的。在 DW环境下，你要考虑销售部门是如何组织销售活动的。他们并不是数据 库管理员，但是他们确定表内的键信息。这里设计人员或者数据库工 作人员应该分析数据库结构从而确定出性能和正确输出之间的最佳条 件。

使用系统生成的主键

这类同技巧 1，但我觉得有必要在这里重复提醒大家。假如你总是在设计数据库 的时候采用系统生成的键作为主键，那么你实际控制了数据库的索引 完整性。这样，数据库和非人工机制就有效地控制了对存储数据中每 一行的访问。
采用系统生成键作为主键还有一个优点：当你拥有一致的键结构时 ，找到逻辑缺陷很容易。

分解字段用于索引

为了分离命名字段和包含字段以支持用户定义的报表 ，请考虑分解其他字段（甚至主键）为其组成要素以便用户可以对其 进行索引。索引将加快 SQL和报表生成器脚本的执行速度。比方说，我通常在必须使用 SQL LIKE 表达式的情况下创建报表，因为 case number 字段无法分解为year、serial number、case type 和 defendant code等要素。性能也会变坏。假如年度和类型字段可以分解为索引字段那 么这些报表运行起来就会快多了。

键设计 4 原则

* 为关联字段创建外键。
* 所有的键都必须唯一。
* 避免使用复合键。
* 外键总是关联唯一的键字段。

别忘了索引

索引是从数据库中获取数据的最高效方式之一。95%的数据库性能问题都可以采用索引技术得到解决。作为一条规则 ，我通常对逻辑主键使用唯一的成组索引，对系统键（作为存储过程 ）采用唯一的非成组索引，对任何外键列[字段]采用非成组索引 。不过，索引就象是盐，太多了菜就咸了。你得考虑数据库的空间有 多大，表如何进行访问，还有这些访问是否主要用作读写。

大多数数据库都索引自动创建的主键字段，但是可别忘了索引外键 ，它们也是经常使用的键，比如运行查询显示主表和所有关联表的某 条记录就用得上。还有，不要索引memo/note 字段，不要索引大型字段（有很多字符），这样作会让索引占用太多 的存储空间。
不要索引常用的小型表不要为小型数据表设置任何键，假如它们经常有插入和删除操作就更 别这样作了。对这些插入和删除操作的索引维护可能比扫描表空间消 耗更多的时间。
不要把社会保障号码（SSN）或身份证号码（ID）选作键。
永远都不要使用 SSN 或 ID 作为数据库的键。除了隐私原因以外，须知政府越来越趋向于不准许 把 SSN 或 ID
用作除收入相关以外的其他目的，SSN 或 ID需要手工输入。永远不要使用手工输入的键作为主键 ，因为一旦你输入错误，你唯一能做的就是删除整个记录然后从头开 始。

我在破解他人的程序时候，我看到很多人把 SSN 或 ID还曾被用做系列号，当然尽管这么做是非法的。而且人们也都知道这 是非法的，但他们已经习惯了。后来，随着盗取身份犯罪案件的增加 ，我现在的同行正痛苦地从一大摊子数据中把 SSN 或 ID 删除。

不要用用户的键

在确定采用什么字段作为表的键的时候，可一定要小心用户将要编辑 的字段。通常的情况下不要选择用户可编辑的字段作为键 。这样做会迫使你采取以下两个措施：
* 在创建记录之后对用户编辑字段的行为施加限制。假如你这么做了 ，你可能会发现你的应用程序在商务需求突然发生变化 ，而用户需要编辑那些不可编辑的字段时缺乏足够的灵活性 。当用户在输入数据之后直到保存记录才发现系统出了问题他们该怎 么想？删除重建？假如记录不可重建是否让用户走开？
* 提出一些检测和纠正键冲突的方法。通常，费点精力也就搞定了 ，但是从性能上来看这样做的代价就比较大了。还有 ，键的纠正可能会迫使你突破你的数据和商业/用户界面层之间的隔 离。
所以还是重提一句老话：你的设计要适应用户而不是让用户来适应你 的设计。

不让主键具有可更新性的原因是在关系模式下，主键实现了不同表之 间的关联。比如，Customer 表有一个主键CustomerID，而客户的定单则存放在另一个表里 。Order 表的主键可能是 OrderNo 或者 OrderNo、CustomerID和日期的组合。不管你选择哪种键设置，你都需要在 Order 表中存放 CustomerID 来保证你可以给下定单的用户找到其定单记录。
假如你在 Customer 表里修改了 CustomerID，那么你必须找出 Order表中的所有相关记录对其进行修改。否则，有些定单就会不属于任何 客户——数据库的完整性就算完蛋了。
如果索引完整性规则施加到表一级，那么在不编写大量代码和附加删 除记录的情况下几乎不可能改变某一条记录的键和数据库内所有关联 的记录。而这一过程往往错误丛生所以应该尽量避免。

可选键(候选键)有时可做主键

记住，查询数据的不是机器而是人。
假如你有可选键，你可能进一步把它用做主键。那样的话 ，你就拥有了建立强大索引的能力。这样可以阻止使用数据库的人不 得不连接数据库从而恰当的过滤数据。在严格控制域表的数据库上 ，这种负载是比较醒目的。如果可选键真正有用，那就是达到了主键 的水准。
我的看法是，假如你有可选键，比如国家表内的state_code，你不要在现有不能变动的唯一键上创建后续 的键。你要做的无非是创建毫无价值的数据。如你因为过度使用表的 后续键[别名]建立这种表的关联，操作负载真得需要考虑一下了。

别忘了外键

大多数数据库索引自动创建的主键字段。但别忘了索引外键字段 ，它们在你想查询主表中的记录及其关联记录时每次都会用到。还有 ，不要索引memo/notes 字段而且不要索引大型文本字段（许多字符），这样做会让你的索引 占据大量的数据库空间。

第 4 部分 - 保证数据的完整性

用约束而非商务规则强制数据完整性

如果你按照商务规则来处理需求，那么你应当检查商务层次 /用户界面：如果商务规则以后发生变化，那么只需要进行更新即可 。假如需求源于维护数据完整性的需要，那么在数据库层面上需要施 加限制条件。如果你在数据层确实采用了约束，你要保证有办法把更 新不能通过约束检查的原因采用用户理解的语言通知用户界面 。除非你的字段命名很冗长，否则字段名本身还不够。

只要有可能，请采用数据库系统实现数据的完整性。这不但包括通过 标准化实现的完整性而且还包括数据的功能性。在写数据的时候还可 以增加触发器来保证数据的正确性。不要依赖于商务层保证数据完整 性；它不能保证表之间（外键）的完整性所以不能强加于其他完整性 规则之上。

分布式数据系统

对分布式系统而言，在你决定是否在各个站点复制所有数据还是把数 据保存在一个地方之前应该估计一下未来 5 年或者 10
年的数据量。当你把数据传送到其他站点的时候，最好在数据库字段 中设置一些标记。在目的站点收到你的数据之后更新你的标记 。为了进行这种数据传输，请写下你自己的批处理或者调度程序以特 定时间间隔运行而不要让用户在每天的工作后传输数据 。本地拷贝你的维护数据，比如计算常数和利息率等 ，设置版本号保证数据在每个站点都完全一致。

强制指示完整性(参照完整性?)

没有好办法能在有害数据进入数据库之后消除它，所以你应该在它进 入数据库之前将其剔除。激活数据库系统的指示完整性特性 。这样可以保持数据的清洁而能迫使开发人员投入更多的时间处理错误条件。

关系

如果两个实体之间存在多对一关系，而且还有可能转化为多对多关系 ，那么你最好一开始就设置成多对多关系。从现有的多对一关系转变 为多对多关系比一开始就是多对多关系要难得多。

采用视图

为了在你的数据库和你的应用程序代码之间提供另一层抽象 ，你可以为你的应用程序建立专门的视图而不必非要应用程序直接访 问数据表。这样做还等于在处理数据库变更时给你提供了更多的自由 。

给数据保有和恢复制定计划

考虑数据保有策略并包含在设计过程中，预先设计你的数据恢复过程 。采用可以发布给用户/开发人员的数据字典实现方便的数据识别同 时保证对数据源文档化。编写在线更新来"更新查询 "供以后万一数据丢失可以重新处理更新。
用存储过程让系统做重活解决了许多麻烦来产生一个具有高度完整性的数据库解决方案之后 ，我决定封装一些关联表的功能组，提供一整套常规的存储过程来访 问各组以便加快速度和简化客户程序代码的开发。数据库不只是一个 存放数据的地方，它也是简化编码之地。

使用查找

控制数据完整性的最佳方式就是限制用户的选择。只要有可能都应该 提供给用户一个清晰的价值列表供其选择。这样将减少键入代码的错 误和误解同时提供数据的一致性。某些公共数据特别适合查找 ：国家代码、状态代码等。

第 5 部分 - 各种小技巧

文档、文档、文档

对所有的快捷方式、命名规范、限制和函数都要编制文档。

采用给表、列[字段]、触发器等加注释的数据库工具。是的 ，这有点费事，但从长远来看，这样做对开发、支持和跟踪修改非常 有用。

取决于你使用的数据库系统，可能有一些软件会给你一些供你很快上 手的文档。你可能希望先开始在说，然后获得越来越多的细节 。或者你可能希望周期性的预排，在输入新数据同时随着你的进展对 每一部分细节化。不管你选择哪种方式，总要对你的数据库文档化 ，或者在数据库自身的内部或者单独建立文档。这样 ，当你过了一年多时间后再回过头来做第2 个版本，你犯错的机会将大大减少。

使用常用英语（或者其他任何语言）而不要使用编码

为什么我们经常采用编码（比如 9935A 可能是'青岛啤酒'的供应代码，4XF788-Q可能是帐目编码）？理由很多。但是用户通常都用英语进行思考而不 是编码。工作 5 年的会计或许知道 4XF788-Q是什么东西，但新来的可就不一定了。在创建下拉菜单、列表 、报表时最好按照英语名排序。假如你需要编码，那你可以在编码旁 附上用户知道的英语。

保存常用信息

让一个表专门存放一般数据库信息非常有用。我常在这个表里存放数 据库当前版本、最近检查/修复（对FoxPro）、关联设计文档的名称、客户等信息 。这样可以实现一种简单机制跟踪数据库，当客户抱怨他们的数据库 没有达到希望的要求而与你联系时，这样做对非客户机 /服务器环境特别有用。

测试、测试、反复测试

建立或者修订数据库之后，必须用用户新输入的数据测试数据字段 。最重要的是，让用户进行测试并且同用户一道保证你选择的数据类 型满足商业要求。测试需要在把新数据库投入实际服务之前完成。

检查设计

在开发期间检查数据库设计的常用技术是通过其所支持的应用程序原 型检查数据库。换句话说，针对每一种最终表达数据的原型应用 ，保证你检查了数据模型并且查看如何取出数据。

Microsoft Visual FoxPro 设计技巧

对复杂的 Microsoft Visual FoxPro数据库应用程序而言，可以把所有的主表放在一个数据库容器文件里 ，然后增加其他数据库表文件和装载同原有数据库有关的特殊文件 。根据需要用这些文件连接到主文件中的主表。比如数据输入 、数据索引、统计分析、向管理层或者政府部门提供报表以及各类只 读查询等。这一措施简化了用户和组权限的分配，而且有利于应用程 序函数（存储过程）的分组和划分，从而在程序必须修改的时候易于 管理。

         最近逛书店发现一本数据建模的好书——《数据建模：分析与设计的工具和技巧》(Data Modeler's Workbench：Tools and Techniques for Analysis and Design)，作者Steve Hoberman。粗读完一遍后，感觉这本书的确无愧于译者和国外专家们的盛赞：“这本书充满了对改进数据模型和设计有益的技术和技巧，并且它还极富阅读乐趣——一个了不起的结合！任何一个数据建模者都应该拥有一本Steve Hoberman的关于数据建模工具和技术的书。”

　　尽管我对自己所掌握的数据建模知识有一定的自负，读完该书后，还是获益良多。本着好书大家一起分享的想法，我把该书的每个章节的总结和技巧建议列出来，以方便手头暂时没有该书的朋友在数据建模时参考。该书所介绍的工具和模版可在作者的Web站点下载，地址是：
　　www.wiley.com/compbooks/hoberman

　　第一章：使用趣闻、类比和演示文稿来阐明数据建模的概念

　　在一般的日常沟通中。我们可能会说出并听到许多故事、或者趣闻这些故事涉及的论题范围很大。有些例子是周末发生在我们自己身边的事情，或者是与我们的工作项目有关的经历。这些趣闻有助于加强我们和周围人们的关系，增进我们的愉悦情绪，而且对我们有教育作用。我们能够把由语言表达出来的东西形象化。有时，当故事结束时，给我们留下的是以前未曾想到的信息或更多的认识。在解释数据建模概念时，趣闻是极其有效的。原因有如下几个：
　　它们建立起持久的形象。
　　它们引人入胜、使人愉悦。
　　它们增经人们之间的关系。
　　它们减缓压力。

　　成功编造并讲述一个数据建模方面的趣闻有下面三个简单的步骤：
　　1)定义一个论题。要在心中保证，你讲述的这个趣闻有一个特定的目标或论题，也就是说，这个故事是为了解释一个数据建模的概念或术语。
　　2)选择你的故事。我们可以选择的故事类型多种多样。我们要考虑选择一个有趣并有益，而且能够明白无误地传达主题意图的简短的故事。
　　3)演练你的故事。一旦找到了合适的故事，你要好好演练一番，直到你自信它能够在两分钟的时间内充分表达你的论题。要避免讲述拖拖拉拉的故事。

　　数据模型类比
　　类比就是把两个或多个概念进行相互比较，以强调它们之间的相似或差异。类比是介绍外来事物或新鲜事物的一个很好的技巧，尤其是向非计算机专业的人士介绍计算机的专业知识时。Hoberman在数据建模中最常见的几个类比如下（他用这些类比轻松的打动管理层给他涨了一倍的工资^_^）：
　　主体域模型是一个居高临下的视点。
　　数据模型是一个设计图。
　　企业模型是一个世界地图。
　　标准就是城市规划。
　　元数据仓储库是一个图书馆。
　　数据仓库是“心脏”。

　　第二章：元数据宾果游戏
　　简单来说，即通过宾果卡片游戏的方式，调动项目团队成员的积极性，来确定数据模型，并确定元数据的有效性。元数据宾果游戏强调“共赢”，如果运气好，游戏结束时每个人都能赢。

　　第三章：确保高质量的定义
　　本章集中讨论一个被称为“定义检查单”(Definition Checklist)的工具，它包含了确保定义的质量处于最高水平的准则。

　　第四章：数据建模者的项目计划
　　本章重点介绍确定数据建模阶段、任务、工具和时限的四个工具：
　　·数据建模阶段的工具：用来确定最高层次上的数据建模步骤。
　　·阶段—任务—工具：提取出“数据建模阶段”的各个阶段并把他们分解成数据建模任务。
　　·优先级三角形：你可以从以下三项中取两项极值：很高的质量、最短的时间与最低的成本，但你永远也别想三者兼得。
　　·可靠的估算工具：“主体域工作量时限”根据应用程序的类型，确定每个数据建模阶段应占整个项目的百分比。“任务工作量工具”提取在“阶段—任务—工具”中确定的每项任务，并列出它们应占整个数据建模工作产品的百分比。这两个工具的组合可使你向项目经理提供一份具有一定精确度的合理估算。

　　第五章：主体域分析
　　本章主要探讨五个关键的工具，这五个工具对数据建模工作的主体域分析阶段有帮组作用。它们应该按照下面的顺序被逐个完成：
　　1)主体域检查单：新应用程序中的主体域的完整列表，还有各个主体域的定义和同义词（或别名）。
　　2)主体域CRUD(Create Read Update Delete)矩阵：包含新应用程序和现有应用程序之间的主体域方面的差别和重复之处，确定应用程序的范围。
　　3)In-the-Know模版：确定完成这个新应用程序的数据间模工作产品所需要的、被用作资源的人员和文档。
　　4)主体域家族树：包含每一个主体域的源应用程序和若干其他的关键信息，阐明主体域数据将来自哪里。
　　5)主体域力度矩阵：使用一个电子表格的格式，记录每一个度量和事实主体域的发布层次。

　　第六章：主体域建模
　　本章阐述三个队主体域信息进行建模的强大工具：
　　·“业务清理板”模型。
　　·“应用程序清理板”模型。
　　·“早期现实性检查”模型。

　　第七章：逻辑数据分析
　　本章关注四个逻辑数据分析工具，它们应该按照下面的次序被使用：
　　1)数据元素家族树：包含应用程序的数据元素的完整列表，以及每个数据元素的来源和变换信息，还有其他几个关键的数据元素元数据。
　　2)数据元素粒度矩阵：用一个电子表格的格式，来记录每个度量和事实的发布层次。
　　3)数据质量记录模板：展示每个数据元素的员数据和一些实际数据的对比。
　　4)数据质量确认模板：记录每个数据元素的元数据和一些实际数据的对比的结果。

　　第八章：规范化之旅和反向规范化生存指南（强烈推荐：是我目前所读过最好的关系型数据库的规范化技术文档）
　　规范化是一个剔除冗余并应用规则的过程，它的目的是为了更好的理解和表达存在于数据元素之间的依赖性和参与性。规范化包含6个层次，最高层是第五范式(5NF)。一般的技术文档上都认为达到3NF即可，Steve Hoberman给我们指明了更高的目标：5NF。Graeme Simsion写过一本名为《Data Modeling Essentials》的书，在这本书中，他写道：“较高层次的范式常被从业者误解并因此而被忽视，或为了支持不可靠的建模时间而被引用。”但是，我们需要理解这些较高层次的规范化，因为它们体现了额外的规范化机会，并帮组我们进一步减少冗余信息、改进设计的灵活性。尽管余下的三个规范化层次有可能仅仅产生次数很少的变化，但它们仍然具有一些提高灵活性和效率的机会。下面是BCNF&4NF&5NF的定义(比国内教材上罗列的数学公式容易理解得多^_^)：
　　BCNF=3NF＋下面的规则：
　　每一个数据元素都完全依赖于键、整个键，而且除依赖于这个键以外，不依赖于任何其他数据元素。
　　4NF=3NF+下面的规则：
　　要把主键中拥有三个或更多外建数据元素、切割格外键之间不存在约束的那些实体分解成两个或更多个实体。
　　5NF=4NF+下面的规则：
　　把主键中拥有三个或更多的外键数据元素，且这些外键数据元素之间存在着约束的实体分解成为所有的约束都需要的多对多的关系。

　　当我们攀上5NF的顶峰后，再根据实际需求情况来进行“反向规范化”增加数据冗余，从而简化开发，提高查询速度。反向规范化是这样一个过程：在定义了一个可靠的、完全规范化了的数据结构之后，你借助这个过程，有选择地引入一些重复的数据，以促进特殊性能需求的实现。Steve Hoberman的“反向规范化生存指南”给如何适当增加冗余提供了一套可计算的评分标准。通过考察每个关系的6个问题，累加各个问题的得分之后，当得分大于等于10时，我们将对该关系进行反向规范化。

　　“反向规范化生存指南”的计分规则：
　　1.关系是什么类型的：该问题确定我们所分析的关系的类型。父实体对于子实体具有什么样的关系？
　　层次关系(20分)
　　同等关系(-10分)
　　确定关系(-20分)
　　2.参与率是多少：该问题确定一个关系中的每个实体的参与性。换句话说，对于一个给定的父实体数值，大概会有几个子实体数值？父与子的关系越接近“一对一”，我们对它进行反向规范化的机会就越大。
　　多达“一对五”的比率(20分)
　　多达“一对一百”的比率(-10分)
　　超过“一对一百”的比率(-20分)
　　3.父实体中有多少个数据元素
　　少于10个数据元素(20分)
　　数据元素的数量介于10到20之间(-10分)
　　多于20个数据元素(-20分)
　　4.使用率是多少：当用户需要来自子的信息时，通常情况下，它们是否还需要来自父的信息呢？换句话说，这两个实体的耦合或相关程度如何？
　　相互之间的关联很强(30分)
　　相互之间的关联较弱或者没有关联(-30分)
　　5.父实体时一个占位符吗：在不远的将来，我们是否还打算向父实体加入更多的数据元素或关系？如果答案是“不”，那么进行反向规范化的可行性就更强。
　　是(20分)
　　不(-20分)
　　6.变动对比率是多少：该问题是为了确定，在同一时间周期内，两个实体的插入和更新的频度是否相近。如果其中一个实体很少变化，而另一个实体却变动频繁，那么，我们就非常倾向于保持它们的规范化状态，把它们放在各自的表中。
　　相同(20分)
　　不同(-20分)

　　“反向规范化生存指南”的使用方法：
　　1)把模型中的关系按照优先级排序
　　2)选择一个关系
　　3)对这个关系回答提问
　　4)如果得分等于或大于10，就进行反向规范化
　　5)返回步骤二，直到完成所有的关系。

　　第九章：抽象化安全指南和组件
　　看过我的“浅谈数据库设计技巧(上) ”的朋友应该还记得我举的第二个例子：网上电子商务平台上的商品信息表的设计。本章将我在上面例子中所用的方法上升到了理论阶段，采用了面向对象的设计，将所有商品的共有属性提取出来，抽象成一个超类，再加入一个表来记录各个不同实体之间的细节来实现超类的派生，从而实现设计的灵活性。当出现下面两种条件的任何场合，抽象化都是极其有用的：
　　设计需要永久维持下去：要求以后尽可能的不修改数据库设计
　　需求可能发生变化：应用程序的需求发生变化，而要求业务流程重组或进行功能升级
　　数据仓库：当新的分类类型从源应用程序中传过来时，我们无须对数据仓库的设计进行任何改动，而只需在分类类型实体加入一个新行即可
　　元数据仓储库：和数据仓库的要求类似

　　当然，抽象化会大大增加工作量和开发的复杂度，而人们通常关注的是非常短期的应用和眼前的成本，而不关心将来的高得多的成本。所以，我非常赞同敏捷软件开发这个观点：在最初几乎不进行预先设计，但是一旦需求发生变化，此时作为一名追求卓越的程序员，应该从头审查整个架构设计，在此次修改中设计出能够满足日后类似修改的系统架构。

　　“抽象组件”就是小型的抽象模型片段，在许多的建模场合(无论是什么行业、组织，甚至什么主体域的建模场合)中，它们都可被反复使用。在键模阶段多次使用抽象化之后，你将开始看到出现的抽象化结构的趋势。这些“抽象组件”有如下的目的：
　　加快设计速度
　　加快开发速度
　　提供通用且有用的机构

　　第十章：数据模型美化技巧
　　本章通过关注如何改进逻辑和物理数据模型的视觉外观，使我们的设计超越直接的应用程序需求。本章中讨论了五个类别的美化技巧：
　　逻辑数据元素排列技巧：这些技巧是一个推荐的、对你的逻辑数据模型中的每一个实体的数据元素进行排序的方法。
　　物理数据元素排序技巧：这些技巧关注数据模型中每一个实体的最佳布局。
　　实体布局技巧：这些技巧关注数据模型中的每一个实体的最佳布局
　　关系布局技巧：这些技巧关注如何调整重叠的关系线条以及看起来穿越（而不是绕过）无关实体的关系
　　吸引注意力的技巧：这些技巧关注如何在我们的涉及中突出的某些元素、实体或关系。

　　第十一章：规划一个长盛不衰的数据建模生涯
　　对数据建模者的十大忠告清单：
　　1)记住：灵活性、准确性和背景
　　2)建模只是你的工作的一小部分
　　3)尝试其他角色
　　4)了解95/5规则：95%的时间将花费在5%的数据元素上
　　5)数据建模从不令人厌烦：如果你一直在做数据建模工作，而且发现自己经常感到厌烦，那么，你的确该改变一下了。这可能不是数据建模领域本身令人厌烦，而是你所在的特定的任务、公司或行业不再令人兴奋。冒险一下，尝试着道一个不同的项目或行业中进行数据建模工作吧！
　　6)站在技术前沿
　　7)尽量不要在模型上牵扯感情因素：建模者必须理解，人们在评审过程中的意见并不是针对模型的创建者，而是针对这个模型的内容。即那句老话：对事不对人。
　　8)让你的创造力展开翅膀：在考虑记录数据需求和改进设计的新方法时，要紧可能有创造性。有创造性也许就意味着修改本书中的某些工具。这还可能意味着提出你自己的电子表格或其他工具。
　　9)单纯的理论太昂贵了：在设计活动过程中，你要确保把这个观点牢记在心。为这个应用程序掏腰包的部门和组织期望看到的是能看得着的实用结果。
　　10)成为一个了不起的会讲故事的人：作为一名数据建模者，讲故事是工作的一个很重要的部分。为了帮组教化和影响项目经理以及对我们行业缺乏理解的其他人，我们需要讲故事或趣闻。

　　最后，我个人觉得，Steve Hoberman所提出的“抽象组件”的观念和面向对象设计中的的“设计模式”非常类似。即数据库专家在多次的数据建模后，将各个项目中的类似部分抽象化，提取出特定的建模模型片段，以后只需在新的项目中对这些模型片段细化派生，即可快速构建出适合于该项目的数据库架构。不过，这些建模模型片段并没有统一，形成标准，目前也没有出版这类的书籍。本人正在陆续总结自己在这方面的经验，但是自知水平有限，不敢在高人面前班门弄斧，只希望自己日后陆续发布的相关文章能起到抛转引玉的作用，争取由中国的程序员率先统一出数据建模领域的“设计模式”。

　　说到数据库，我认为不能不先谈数据结构。1996年，在我初入大学学习计算机编程时，当时的老师就告诉我们说：计算机程序＝数据结构＋算法。尽管现在的程序开发已由面向过程为主逐步过渡到面向对象为主，但我还是深深赞同8年前老师的告诉我们的公式：计算机程序＝数据结构＋算法。面向对象的程序开发，要做的第一件事就是，先分析整个程序中需处理的数据，从中提取出抽象模板，以这个抽象模板设计类，再在其中逐步添加处理其数据的函数(即算法)，最后，再给类中的数据成员和函数划分访问权限，从而实现封装。

　　数据库的最初雏形据说源自美国一个奶牛场的记账薄(纸质的，由此可见，数据库并不一定是存储在电脑里的数据^_^)，里面记录的是该奶牛场的收支账目，程序员在将其整理、录入到电脑中时从中受到启发。当按照规定好的数据结构所采集到的数据量大到一定程度后，出于程序执行效率的考虑，程序员将其中的检索、更新维护等功能分离出来，做成单独调用的模块，这个模块后来就慢慢发展、演变成现在我们所接触到的数据库管理系统(DBMS)——程序开发中的一个重要分支。

　　下面进入正题，首先按我个人所接触过的程序给数据库设计人员的功底分一下类：
　　１、没有系统学习过数据结构的程序员。这类程序员的作品往往只是他们的即兴玩具，他们往往习惯只设计有限的几个表，实现某类功能的数据全部塞在一个表中，各表之间几乎毫无关联。网上不少的免费管理软件都是这样的东西，当程序功能有限，数据量不多的时候，其程序运行起来没有什么问题，但是如果用其管理比较重要的数据，风险性非常大。
　　２、系统学习过数据结构，但是还没有开发过对程序效率要求比较高的管理软件的程序员。这类人多半刚从学校毕业不久，他们在设计数据库表结构时，严格按照教科书上的规定，死扣E-R图和3NF(别灰心，所有的数据库设计高手都是从这一步开始的)。他们的作品，对于一般的access型轻量级的管理软件，已经够用。但是一旦该系统需要添加新功能，原有的数据库表差不多得进行大换血。
　　３、第二类程序员，在经历过数次程序效率的提升，以及功能升级的折腾后，终于升级成为数据库设计的老鸟，第一类程序员眼中的高人。这类程序员可以胜任二十个表以上的中型商业数据管理系统的开发工作。他们知道该在什么样的情况下保留一定的冗余数据来提高程序效率，而且其设计的数据库可拓展性较好，当用户需要添加新功能时，原有数据库表只需做少量修改即可。
　　４、在经历过上十个类似数据库管理软件的重复设计后，第三类程序员中坚持下来没有转行，而是希望从中找出“偷懒”窍门的有心人会慢慢觉悟，从而完成量变到质变的转换。他们所设计的数据库表结构有一定的远见，能够预测到未来功能升级所需要的数据，从而预先留下伏笔。这类程序员目前大多晋级成数据挖掘方面的高级软件开发人员。
　　５、第三类程序员或第四类程序员，在对现有的各家数据库管理系统的原理和开发都有一定的钻研后，要么在其基础上进行二次开发，要么自行开发一套有自主版权的通用数据库管理系统。

　　我个人正处于第三类的末期，所以下面所列出的一些设计技巧只适合第二类和部分第三类数据库设计人员。同时，由于我很少碰到有兴趣在这方面深钻下去的同行，所以文中难免出现错误和遗漏，在此先行声明，欢迎大家指正，不要藏私哦8)

　　一、树型关系的数据表
　　不少程序员在进行数据库设计的时候都遇到过树型关系的数据，例如常见的类别表，即一个大类，下面有若干个子类，某些子类又有子类这样的情况。当类别不确定，用户希望可以在任意类别下添加新的子类，或者删除某个类别和其下的所有子类，而且预计以后其数量会逐步增长，此时我们就会考虑用一个数据表来保存这些数据。按照教科书上的教导，第二类程序员大概会设计出类似这样的数据表结构：

类别表_1(Type_table_1)
名称　　　　　类型　　　　约束条件　　　说明
type_id 　 int 　 无重复　　 类别标识，主键
type_name　　 char(50) 不允许为空 类型名称，不允许重复
type_father int 不允许为空 该类别的父类别标识，如果是顶节点的话设定为某个唯一值

　　这样的设计短小精悍，完全满足3NF，而且可以满足用户的所有要求。是不是这样就行呢？答案是NO！Why？

　　我们来估计一下用户希望如何罗列出这个表的数据的。对用户而言，他当然期望按他所设定的层次关系一次罗列出所有的类别，例如这样：
总类别
　　类别1
　　　　类别1.1
　　　　　　类别1.1.1
　　　　类别1.2
　　类别2
　　　　类别2.1
　　类别3
　　　　类别3.1
　　　　类别3.2
　　……

　　看看为了实现这样的列表显示(树的先序遍历)，要对上面的表进行多少次检索？注意，尽管类别1.1.1可能是在类别3.2之后添加的记录，答案仍然是N次。这样的效率对于少量的数据没什么影响，但是日后类型扩充到数十条甚至上百条记录后，单单列一次类型就要检索数十次该表，整个程序的运行效率就不敢恭维了。或许第二类程序员会说，那我再建一个临时数组或临时表，专门保存类型表的先序遍历结果，这样只在第一次运行时检索数十次，再次罗列所有的类型关系时就直接读那个临时数组或临时表就行了。其实，用不着再去分配一块新的内存来保存这些数据，只要对数据表进行一定的扩充，再对添加类型的数量进行一下约束就行了，要完成上面的列表只需一次检索就行了。下面是扩充后的数据表结构：

类别表_2(Type_table_2)
名称　　　　　类型　　　　约束条件　　　 说明
type_id 　 int 　 无重复　　 类别标识，主键
type_name　　 char(50) 不允许为空 类型名称，不允许重复
type_father int 不允许为空 该类别的父类别标识，如果是顶节点的话设定为某个唯一值
type_layer char(6) 限定3层,初始值为000000 类别的先序遍历，主要为减少检索数据库的次数

　　按照这样的表结构，我们来看看上面例子记录在表中的数据是怎样的：

type_id type_name type_father type_layer
1 总类别 0 000000
2 类别1 1 010000
3 类别1.1 2 010100
4 类别1.2 2 010200
5 类别2 1 020000
6 类别2.1 5 020100
7 类别3 1 030000
8 类别3.1 7 030100
9 类别3.2 7 030200
10 类别1.1.1 3 010101
……

　　现在按type_layer的大小来检索一下：SELECT * FROM Type_table_2 ORDER BY type_layer

列出记录集如下：

type_id type_name type_father type_layer
1 总类别 0 000000
2 类别1 1 010000
3 类别1.1 2 010100
10 类别1.1.1 3 010101
4 类别1.2 2 010200
5 类别2 1 020000
6 类别2.1 5 020100
7 类别3 1 030000
8 类别3.1 7 030100
9 类别3.2 7 030200
……

　　现在列出的记录顺序正好是先序遍历的结果。在控制显示类别的层次时，只要对type_layer字段中的数值进行判断，每2位一组，如大于0则向右移2个空格。当然，我这个例子中设定的限制条件是最多3层，每层最多可设99个子类别，只要按用户的需求情况修改一下type_layer的长度和位数，即可更改限制层数和子类别数。其实，上面的设计不单单只在类别表中用到，网上某些可按树型列表显示的论坛程序大多采用类似的设计。

　　或许有人认为，Type_table_2中的type_father字段是冗余数据，可以除去。如果这样，在插入、删除某个类别的时候，就得对type_layer 的内容进行比较繁琐的判定，所以我并没有消去type_father字段，这也正符合数据库设计中适当保留冗余数据的来降低程序复杂度的原则，后面我会举一个故意增加数据冗余的案例。

　　
　　二、商品信息表的设计
　　假设你是一家百货公司电脑部的开发人员，某天老板要求你为公司开发一套网上电子商务平台，该百货公司有数千种商品出售，不过目前仅打算先在网上销售数十种方便运输的商品，当然，以后可能会陆续在该电子商务平台上增加新的商品出售。现在开始进行该平台数据库的商品信息表的设计。每种出售的商品都会有相同的属性，如商品编号，商品名称，商品所属类别，相关信息，供货厂商，内含件数，库存，进货价，销售价，优惠价。你很快就设计出4个表：商品类型表(Wares_type)，供货厂商表(Wares_provider)，商品信息表(Wares_info)：

商品类型表(Wares_type)
名称　　　　　类型　　　　约束条件　　　 说明
type_id 　 int 　 无重复　　 类别标识，主键
type_name　　 char(50) 不允许为空 类型名称，不允许重复
type_father int 不允许为空 该类别的父类别标识，如果是顶节点的话设定为某个唯一值
type_layer char(6) 限定3层,初始值为000000 类别的先序遍历，主要为减少检索数据库的次数

供货厂商表(Wares_provider)
名称　　　　　类型　　　　约束条件　　　 说明
provider_id int 　 无重复　　 供货商标识，主键
provider_name char(100) 不允许为空 供货商名称

商品信息表(Wares_info)
名称　　　　 类型　　　　约束条件　　　 说明
wares_id int 　 无重复　　 商品标识，主键
wares_name char(100) 不允许为空 商品名称
wares_type　　 int 不允许为空　　　　　　　　　　 商品类型标识，和Wares_type.type_id关联
wares_info char(200) 允许为空 相关信息
provider int 不允许为空 供货厂商标识，和Wares_provider.provider_id关联
setnum int 初始值为1 内含件数，默认为1
stock int 初始值为0 库存，默认为0
buy_price money 不允许为空 进货价
sell_price money 不允许为空 销售价
discount money 不允许为空 优惠价

　　你拿着这3个表给老板检查，老板希望能够再添加一个商品图片的字段，不过只有一部分商品有图片。OK，你在商品信息表(Wares_info)中增加了一个haspic的BOOL型字段，然后再建了一个新表——商品图片表(Wares_pic)：

商品图片表(Wares_pic)
名称　　　　 类型　　　　约束条件　　　 说明
pic_id int 　 无重复　　 商品图片标识，主键
wares_id int 不允许为空 所属商品标识，和Wares_info.wares_id关联
pic_address　 char(200) 不允许为空　　　　　　　　　　 图片存放路径

　　程序开发完成后，完全满足老板目前的要求，于是正式启用。一段时间后，老板打算在这套平台上推出新的商品销售，其中，某类商品全部都需添加“长度”的属性。第一轮折腾来了……当然，你按照添加商品图片表的老方法，在商品信息表(Wares_info)中增加了一个haslength的BOOL型字段，又建了一个新表——商品长度表(Wares_length)：

商品长度表(Wares_length)
名称　　　　 类型　　　　约束条件　　　 说明
length_id int 　 无重复　　 商品图片标识，主键
wares_id int 不允许为空 所属商品标识，和Wares_info.wares_id关联
length　 char(20) 不允许为空　　　　　　　　　　 商品长度说明

　　刚刚改完没多久，老板又打算上一批新的商品，这次某类商品全部需要添加“宽度”的属性。你咬了咬牙，又照方抓药，添加了商品宽度表(Wares_width)。又过了一段时间，老板新上的商品中有一些需要添加“高度”的属性，你是不是开始觉得你所设计的数据库按照这种方式增长下去，很快就能变成一个迷宫呢？那么，有没有什么办法遏制这种不可预见性，但却类似重复的数据库膨胀呢？我在阅读《敏捷软件开发：原则、模式与实践》中发现作者举过类似的例子：7.3　“Copy”程序。其中，我非常赞同敏捷软件开发这个观点：在最初几乎不进行预先设计，但是一旦需求发生变化，此时作为一名追求卓越的程序员，应该从头审查整个架构设计，在此次修改中设计出能够满足日后类似修改的系统架构。下面是我在需要添加“长度”的属性时所提供的修改方案：

　　去掉商品信息表(Wares_info)中的haspic字段，添加商品额外属性表(Wares_ex_property)和商品额外信息表(Wares_ex_info)2个表来完成添加新属性的功能。

商品额外属性表(Wares_ex_property)
名称　　　　 类型　　　　约束条件　　　 说明
ex_pid int 　 无重复　　 商品额外属性标识，主键
p_name char(20) 不允许为空 额外属性名称

商品额外信息表(Wares_ex_info)
名称　　　　 类型　　　　约束条件　　　 说明
ex_iid int 　 无重复　　 商品额外信息标识，主键
wares_id int 不允许为空 所属商品标识，和Wares_info.wares_id关联
property_id　 int 不允许为空　　　　　　　　　　 商品额外属性标识，和Wares_ex_property.ex_pid关联
property_value char(200) 不允许为空 商品额外属性值

　　在商品额外属性表(Wares_ex_property)中添加2条记录：
ex_pid p_name
1 商品图片
2 商品长度

　　再在整个电子商务平台的后台管理功能中追加一项商品额外属性管理的功能，以后添加新的商品时出现新的属性，只需利用该功能往商品额外属性表(Wares_ex_property)中添加一条记录即可。不要害怕变化，被第一颗子弹击中并不是坏事，坏的是被相同轨道飞来的第二颗、第三颗子弹击中。第一颗子弹来得越早，所受的伤越重，之后的抵抗力也越强8)

　　三、多用户及其权限管理的设计
　　开发数据库管理类的软件，不可能不考虑多用户和用户权限设置的问题。尽管目前市面上的大、中型的后台数据库系统软件都提供了多用户，以及细至某个数据库内某张表的权限设置的功能，我个人建议：一套成熟的数据库管理软件，还是应该自行设计用户管理这块功能，原因有二：
　　1.那些大、中型后台数据库系统软件所提供的多用户及其权限设置都是针对数据库的共有属性，并不一定能完全满足某些特例的需求；
　　2.不要过多的依赖后台数据库系统软件的某些特殊功能，多种大、中型后台数据库系统软件之间并不完全兼容。否则一旦日后需要转换数据库平台或后台数据库系统软件版本升级，之前的架构设计很可能无法重用。

　　下面看看如何自行设计一套比较灵活的多用户管理模块，即该数据库管理软件的系统管理员可以自行添加新用户，修改已有用户的权限，删除已有用户。首先，分析用户需求，列出该数据库管理软件所有需要实现的功能；然后，根据一定的联系对这些功能进行分类，即把某类用户需使用的功能归为一类；最后开始建表：
　　
功能表(Function_table)
名称　　类型　 约束条件　　　说明
f_id int 　 无重复　　 功能标识，主键
f_name char(20) 不允许为空 功能名称，不允许重复
f_desc char(50) 允许为空 功能描述

用户组表(User_group)
名称　　 类型　 约束条件　　　说明
group_id int 无重复 用户组标识，主键
group_name char(20) 不允许为空 用户组名称
group_power char(100) 允许为空 用户组权限表，内容为功能表f_id的集合

用户表(User_table)
名称　　　　类型　　　　约束条件　　　说明
user_id int 无重复 用户标识，主键
user_name char(20) 无重复 用户名
user_pwd char(20) 不允许为空 用户密码
user_type int 不允许为空 所属用户组标识，和User_group.group_id关联

　　采用这种用户组的架构设计，当需要添加新用户时，只需指定新用户所属的用户组；当以后系统需要添加新功能或对旧有功能权限进行修改时，只用操作功能表和用户组表的记录，原有用户的功能即可相应随之变化。当然，这种架构设计把数据库管理软件的功能判定移到了前台，使得前台开发相对复杂一些。但是，当用户数较大(10人以上)，或日后软件升级的概率较大时，这个代价是值得的。

　　四、简洁的批量m:n设计
　　碰到m:n的关系，一般都是建立3个表，m一个，n一个，m:n一个。但是，m:n有时会遇到批量处理的情况，例如到图书馆借书，一般都是允许用户同时借阅n本书，如果要求按批查询借阅记录，即列出某个用户某次借阅的所有书籍，该如何设计呢？让我们建好必须的3个表先：

书籍表(Book_table)
名称　　　类型　　　　约束条件　　　说明
book_id int 无重复 书籍标识，主键
book_no char(20) 无重复 书籍编号
book_name char(100) 不允许为空 书籍名称
……

借阅用户表(Renter_table)
名称　　　　类型　　　　约束条件　　　说明
renter_id int 无重复 用户标识，主键
renter_name char(20) 不允许为空 用户姓名
……

借阅记录表(Rent_log)
名称　　　类型　　　　约束条件　　　说明
rent_id int 无重复 借阅记录标识，主键
r_id int 不允许为空 用户标识，和Renter_table.renter_id关联
b_id int 不允许为空 书籍标识，和Book_table.book_id关联
rent_date datetime 不允许为空 借阅时间
……

　　为了实现按批查询借阅记录，我们可以再建一个表来保存批量借阅的信息，例如：

批量借阅表(Batch_rent)
名称　　　类型　　　约束条件　　　说明
batch_id int 无重复 批量借阅标识，主键
batch_no int 不允许为空 批量借阅编号，同一批借阅的batch_no相同
rent_id int 不允许为空 借阅记录标识，和Rent_log.rent_id关联
batch_date datetime 不允许为空 批量借阅时间

　　这样的设计好吗？我们来看看为了列出某个用户某次借阅的所有书籍，需要如何查询？首先检索批量借阅表(Batch_rent)，把符合条件的的所有记录的rent_id字段的数据保存起来，再用这些数据作为查询条件带入到借阅记录表(Rent_log)中去查询。那么，有没有什么办法改进呢？下面给出一种简洁的批量设计方案，不需添加新表，只需修改一下借阅记录表(Rent_log)即可。修改后的记录表(Rent_log)如下：

借阅记录表(Rent_log)
名称　　　类型　　　约束条件　　　说明
rent_id int 无重复 借阅记录标识，主键
r_id int 不允许为空 用户标识，和Renter_table.renter_id关联
b_id int 不允许为空 书籍标识，和Book_table.book_id关联
batch_no int 不允许为空 批量借阅编号，同一批借阅的batch_no相同
rent_date datetime 不允许为空 借阅时间
……

　　其中，同一次借阅的batch_no和该批第一条入库的rent_id相同。举例：假设当前最大rent_id是64，接着某用户一次借阅了3本书，则批量插入的3条借阅记录的batch_no都是65。之后另外一个用户租了一套碟，再插入出租记录的rent_id是68。采用这种设计，查询批量借阅的信息时，只需使用一条标准T_SQL的嵌套查询即可。当然，这种设计不符合3NF，但是和上面标准的3NF设计比起来，哪一种更好呢？答案就不用我说了吧。

　　五、冗余数据的取舍
　　上篇的“树型关系的数据表”中保留了一个冗余字段，这里的例子更进一步——添加了一个冗余表。先看看例子：我原先所在的公司为了解决员工的工作餐，和附近的一家小餐馆联系，每天吃饭记账，费用按人数平摊，月底由公司现金结算，每个人每个月的工作餐费从工资中扣除。当然，每天吃饭的人员和人数都不是固定的，而且，由于每顿工作餐的所点的菜色不同，每顿的花费也不相同。例如，星期一中餐5人花费40元，晚餐2人花费20，星期二中餐6人花费36元，晚餐3人花费18元。为了方便计算每个人每个月的工作餐费，我写了一个简陋的就餐记账管理程序，数据库里有3个表：

员工表(Clerk_table)
名称　　　　类型　　　　约束条件　　　说明
clerk_id int 无重复 员工标识，主键
clerk_name char(10) 不允许为空 员工姓名

每餐总表(Eatdata1)
名称　　　 类型　　　　约束条件　　　说明
totle_id int 无重复 每餐总表标识，主键
persons char(100) 不允许为空 就餐员工的员工标识集合
eat_date datetime 不允许为空 就餐日期
eat_type char(1) 不允许为空 就餐类型，用来区分中、晚餐
totle_price money 不允许为空 每餐总花费
persons_num int 不允许为空 就餐人数

就餐计费细表(Eatdata2)
名称　　类型　　约束条件　　　说明
id int 无重复 就餐计费细表标识，主键
t_id int 不允许为空 每餐总表标识，和Eatdata1.totle_id关联
c_id int 不允许为空 员工标识标识，和Clerk_table.clerk_id关联
price money 不允许为空 每人每餐花费

　　其中，就餐计费细表(Eatdata2)的记录就是把每餐总表(Eatdata1)的一条记录按就餐员工平摊拆开，是个不折不扣的冗余表。当然，也可以把每餐总表(Eatdata1)的部分字段合并到就餐计费细表(Eatdata2)中，这样每餐总表(Eatdata1)就成了冗余表，不过这样所设计出来的就餐计费细表重复数据更多，相比来说还是上面的方案好些。但是，就是就餐计费细表(Eatdata2)这个冗余表，在做每月每人餐费统计的时候，大大简化了编程的复杂度，只用类似这么一条查询语句即可统计出每人每月的寄餐次数和餐费总帐：

SELECT clerk_name AS personname,COUNT(c_id) as eattimes,SUM(price) AS ptprice FROM Eatdata2 JOIN Clerk_tabsle ON (c_id=clerk_id) JOIN eatdata1 ON (totleid=tid) WHERE eat_date>=CONVERT(datetime,'"&the_date&"') AND eat_date

　　想象一下，如果不用这个冗余表，每次统计每人每月的餐费总帐时会多麻烦，程序效率也够呛。那么，到底什么时候可以增加一定的冗余数据呢？我认为有2个原则：

　　１、用户的整体需求。当用户更多的关注于，对数据库的规范记录按一定的算法进行处理后，再列出的数据。如果该算法可以直接利用后台数据库系统的内嵌函数来完成，此时可以适当的增加冗余字段，甚至冗余表来保存这些经过算法处理后的数据。要知道，对于大批量数据的查询，修改或删除，后台数据库系统的效率远远高于我们自己编写的代码。
　　２、简化开发的复杂度。现代软件开发，实现同样的功能，方法有很多。尽管不必要求程序员精通绝大部分的开发工具和平台，但是还是需要了解哪种方法搭配哪种开发工具的程序更简洁，效率更高一些。冗余数据的本质就是用空间换时间，尤其是目前硬件的发展远远高于软件，所以适当的冗余是可以接受的。不过我还是在最后再强调一下：不要过多的依赖平台和开发工具的特性来简化开发，这个度要是没把握好的话，后期维护升级会栽大跟头的。