精华内容
下载资源
问答
  • 数据库表设计原则

    2013-06-06 23:08:11
    不同组件间所对应的数据库表间的关  联应尽可能减少,如果不同组件间的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表结构 的

         数据库表的12条设计原则

        1.  不应针对整个系统设计数据库的表,而应该根据系统架构中的组件划分,针对每个组件所处理的业务进行组件单元的数据库设计。不同组件间所对应的数据库表间的关

                    联应尽可能减少,如果不同组件间的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表结构 的

                    重构提供可能性。


           2.         采用域模型驱动的方式和自顶向下的思路进行数据库设计,首先分析系统业务,根据职责定义对象。对象要符合封装的特性,确保与职责相关的数据项被定义在

                       一个 对象之内,这些数据项能够完整描述该职责,不会出现职责缺失,并且一个对象有且只有一项职责,如果一个对象要负责两个或以上的职责,应进行拆分。


           3.         根据建立的领域模型可以数据库表的映射,此时应参考数据库设计第二范式:一个表的所有非关键值属性都依赖于整个关键字,关键字可以是一个属性,也可以是个

                        属的集合,不论哪种方式,都应确保关键字能够保证唯一性。在确定关键时,应保证关键字不会参与业务且不会出现更新异常,这时,最优解决方案为采用一个自数

                        值型属性或一个随机字符串作为表的关键字。


           4.          由于第一点所述的领域模型驱动的方式设计数据库表的结构,领域模型中的每一个对象只有一项职责,所以对象中的数据项不存在传递依赖,所以,这种思路的数项

                        的数据库表结构设计从一开始即满足第三范式:一个表应满足第二范式,且属性间不存在依赖传递。


           5.         同样,由于对象职责的单一性以及对象之间的关系的是业务逻辑之间的关系,所以在领域模型中的对象存在主对象和从对象之分,从对象是从1-N或N-N的角度进步

                        对象的业务逻辑,所以从对象及对象关系映射为的表及表关联关系不存在删除和插入异常。


           6.         在映射后得出的数据库表结构中,应再根据第四范式进一步修改,确保不存在多值依赖。这时,就根据反向工程的思路反馈给领域模型,如果表结构中存在多值赖,

                        则证明领域模型中的对象具有至少两个以上的职责,应根据第一条进行设计修正。第四范式:一个表如果满足BCNF,不应存在多值依赖。


           7.         在经过分析后确认所有的表都满足二,三,四范式的情况下,表和表之间的关联尽量采用弱关系以便于对表的字段和表的结构的调整和重构,并且,我认为数据库中

                       的表是用来持久化一个对象实例在特定时间及特定条件下的状态的,只是一个存储介质,所以,表和表这间不应采用强关联来表述业务(数据库的一至性)。这一职

                       责应由系统的逻辑层来保证,这种方式也确保了系统对于不正确的数据(脏数据)的兼容性。当然,从整个系统的角度来说我们还是尽最大的努力确保系统不会产

                       生脏数据,单从另一个角度来说,脏数据的产生在一定程度上也是不可避免的,我们也要保证系统对这种情况的容错性,这是一个折中的方案。


           8.         应针对所有表的主键和外键建立索引,有针对性的(针对大数据量和常用的检索方式)建立组合属性的索引,提高检索性能。虽然建立索引会消耗部分系统资源,

                       但比较起来检索时搜索整张表中的数据尤其时 表的数据量较大时所带来的性能影响,以及无索引时的排序操作所带的性能影响,这种方式仍然是值得提倡的。


           9.         尽量少用存储过程,目前已经有很多技术可以替代存储过程的功能和“对象/关系映射”等,将数据一致性的保证放在数据库中,无论对于版本控制,开发和部署,以及

                       数据库的迁移都会带来很大影响,但不否认,在储过程具有性能上的优势,所以,当系统可使用的硬件水平不会得到提升而性能又是非常重要的质量属性时,可经过

                       平衡考虑选用存储过程。


          10.        当处理表间的关联约束所付出的代价(常常是使用性上的代价)超过了保证不会出现修改,删除,更新的异常所付出的代价,并且数据冗余也不是主要的问题,表

                        设计可以不符合第四范式,四个范式确保了不会出现异常,但也可能由此导致过于纯洁设计,便用表的结构难于使用,所以在设计时需要进行综合调整,但首先是

                        确保符合四个范式,然后再进行精化修正是刚刚进入数据库设计领域时可以采用最好方法。


          11.        设计出的表要具有较好的使用性,主要体现在查询时是否需要关联多张表且还需使用复杂的SQL技巧。


          12.        设计出的表要尽可能减少数据冗余,确保数据的准备性,有效的控制冗余有助于提高数据库性能。


    展开全文
  • 数据库表设计原则

    2014-08-25 00:16:00
    不同组件所对应的数据库 之间的关联应尽可能减少,如果不同组件需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的之间的独立性,为系统 或结构的重构提供可能性。...

    (1)不应针对整个系统进行数据库设计,而应该根据系统架构中的组件划分,针对每个组件所处理的业务进行组件单元的数据库设计;不同组件间所对应的数据库 表之间的关联应尽可能减少,如果不同组件间的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统 或表结构的重构提供可能性。

    (2)采用领域模型驱动的方式和自顶向下的思路进行数据库设计,首先分析系统业务,根据职责定义对象。对象要符合封装的特性,确保与职责相关的数据项被定 义在一个对象之内,这些数据项能够完整描述该职责,不会出现职责描述缺失。并且一个对象有且只有一项职责,如果一个对象要负责两个或两个以上的职责,应进 行分拆。

    (3)根据建立的领域模型进行数据库表的映射,此时应参考数据库设计第二范式:一个表中的所有非关键字属性都依赖于整个关键字。关键字可以是一个属性,也 可以是多个属性的集合,不论那种方式,都应确保关键字能够保证唯一性。在确定关键字时,应保证关键字不会参与业务且不会出现更新异常,这时,最优解决方案 为采用一个自增数值型属性或一个随机字符串作为表的关键字。

    (4)由于第一点所述的领域模型驱动的方式设计数据库表结构,领域模型中的每一个对象只有一项职责,所以对象中的数据项不存在传递依赖,所以,这种思路的数据库表结构设计从一开始即满足第三范式:一个表应满足第二范式,且属性间不存在传递依赖。

    (5)同样,由于对象职责的单一性以及对象之间的关系反映的是业务逻辑之间的关系,所以在领域模型中的对象存在主对象和从对象之分,从对象是从1-N或N-N的角度进一步主对象的业务逻辑,所以从对象及对象关系映射为的表及表关联关系不存在删除和插入异常。

    (6)在映射后得出的数据库表结构中,应再根据第四范式进行进一步修改,确保不存在多值依赖。这时,应根据反向工程的思路反馈给领域模型。如果表结构中存 在多值依赖,则证明领域模型中的对象具有至少两个以上的职责,应根据第一条进行设计修正。第四范式:一个表如果满足BCNF,不应存在多值依赖。

    (7)在经过分析后确认所有的表都满足二、三、四范式的情况下,表和表之间的关联尽量采用弱关联以便于对表字段和表结构的调整和重构。并且,我认为数据库 中的表是用来持久化一个对象实例在特定时间及特定条件下的状态的,只是一个存储介质,所以,表和表之间也不应用强关联来表述业务(数据间的一致性),这一 职责应由系统的逻辑层来保证,这种方式也确保了系统对于不正确数据(脏数据)的兼容性。当然,从整个系统的角度来说我们还是要尽最大努力确保系统不会产生 脏数据,单从另一个角度来说,脏数据的产生在一定程度上也是不可避免的,我们也要保证系统对这种情况的容错性。这是一个折中的方案。

    (8)应针对所有表的主键和外键建立索引,有针对性的(针对一些大数据量和常用检索方式)建立组合属性的索引,提高检索效率。虽然建立索引会消耗部分系统 资源,但比较起在检索时搜索整张表中的数据尤其时表中的数据量较大时所带来的性能影响,以及无索引时的排序操作所带来的性能影响,这种方式仍然是值得提倡 的。

    (9)尽量少采用存储过程,目前已经有很多技术可以替代存储过程的功能如“对象/关系映射”等,将数据一致性的保证放在数据库中,无论对于版本控制、开发 和部署、以及数据库的迁移都会带来很大的影响。但不可否认,存储过程具有性能上的优势,所以,当系统可使用的硬件不会得到提升而性能又是非常重要的质量属 性时,可经过平衡考虑选用存储过程。

    (10)当处理表间的关联约束所付出的代价(常常是使用性上的代价)超过了保证不会出现修改、删除、更改异常所付出的代价,并且数据冗余也不是主要的问题 时,表设计可以不符合四个范式。四个范式确保了不会出现异常,但也可能由此导致过于纯洁的设计,使得表结构难于使用,所以在设计时需要进行综合判断,但首 先确保符合四个范式,然后再进行精化修正是刚刚进入数据库设计领域时可以采用的最好办法。

    (11)设计出的表要具有较好的使用性,主要体现在查询时是否需要关联多张表且还需使用复杂的SQL技巧。

    (12)设计出的表要尽可能减少数据冗余,确保数据的准确性,有效的控制冗余有助于提高数据库的性能。

    from:http://www.blogjava.net/Jack2007/archive/2008/05/05/198412.html

    转载于:https://www.cnblogs.com/kivmi/p/3933948.html

    展开全文
  • 数据库表设计

    2020-12-14 21:13:23
    也可以说当我们把一个数据库表当作一个实体,那么它里面的所有字段是不是是一个属性了呢?结果是肯定的。  二、实体间的联系  我想说的是,很简单,数据库里表跟表间的关系莫过于三种:一对一;多对多;一对多。...
  • 通用Excel是一个用于构建信息系统的设计与运行平台,以Excel为操作界面,让用户自主管理、按需定制开发、不用编程,结合SQLServer数据库,通过在Excel中设计模板、表间公式、工作流等,即可轻松构建适合企业自身现状...
  • 依据数据库表中的信息设计简单的java类,其实利用了上次课学习java,类间关联以及自身关联和合成设计模式实现。以下通过案例讲解数据库表与java类的的映射处理 (1)、数据表=类的定义 (2)、数据库表的字段=类的...

    数据库表的映射与java类映射处理

    1、数据库表与简单java类的映射处理

    依据数据库表中的信息设计简单的java类,其实利用了上次课学习java,类间关联以及自身关联和合成设计模式实现。以下通过案例讲解数据库表与java类的的映射处理

    个人理解:如果有需要相关联的属性,不要急着将其封装,因为如果是单向联系的属性并不需要进行封装,只要定义getter、setter方法就可以了。这样就可以在实例化以后通过getter、setter方法建立联系。

    数据表与简单Java类映射关系:(必须熟练掌握!)

    • 数据实体表的设计 = 类的定义

    • 表中的字段 = 类的成员属性

    • 表的外键关联 = 引用关联

    • 表的一行记录 = 一个实例化对象

    • 表的多行记录 = 对象数组

    • 表与表的关系不需要设置类

    例子:

    一个部门有多个雇员(类间关联)
    一个雇员属于一个部门(类间关联)
    一个雇员有一个领导(自身关联)

    class emp{
    private Long eid; //员工ID

    private String ename; //员工姓名

    private String ejop; //员工职业

    private dep dep; // 员工所属部门

    private emp emp;//领导人

    //设置setter 和getter方法

    public dep getDep() {
    return dep;

    }

    public void setDep(dep dep) {
    this.dep = dep;

    }

    public emp getEmp() {
    return emp;

    }

    public void setEmp(emp emp) {
    this.emp = emp;

    }

    public Long getEid() {
    return eid;

    }

    public void setEid(Long eid) {
    this.eid = eid;

    }

    public String getEname() {
    return ename;

    }

    public void setEname(String ename) {
    this.ename = ename;

    }

    public String getEjop() {
    return ejop;

    }

    public void setEjop(String ejop) {
    this.ejop = ejop;

    }

    public String getInfo() {
    return “【员工信息】员工编号=”+this.getEid()+"、员工姓名="+this.getEname()+"、员工职业+"+this.getEjop();

    }

    public emp(Long eid, String ename, String ejop) {
    super();

    this.eid = eid;

    this.ename = ename;

    this.ejop = ejop;

    }

    }

    class dep{
    private Long did;

    private String dname;

    private emp emp [];

    public dep(Long did, String dname) {
    super();

    this.did = did;

    this.dname = dname;

    }

    //设置setter 和getter方法

    public emp[] getEmp() {
    return emp;

    }

    public void setEmp(emp[] emp) {
    this.emp = emp;

    }

    public Long getDid() {
    return did;

    }

    public void setDid(Long did) {
    this.did = did;

    }

    public String getDname() {
    return dname;

    }

    public void setDname(String dname) {
    this.dname = dname;

    }

    public String getInfo() {
    return “【部门信息】部门编号=”+this.getDname()+"、部门名称="+this.getDname();

    }

    }

    public class javaDamo {
    public static void main(String[] args) {
    emp empA=new emp(10001L, “王五”, “普通员工”);

    emp empB=new emp(10002L, “王四”, “普通员工”);

    emp empC=new emp(10003L, “王三”, “管理层员工”);

    dep depA=new dep(10001L, “财务部”);

    dep depB=new dep(10002L, “人事部”);

    //设置员工领导人

    empA.setEmp(empC);

    empB.setEmp(empC);

    //设置员工部门

    empA.setDep(depA);

    empB.setDep(depB);

    empC.setDep(depB);

    //部门设置员工

    depA.setEmp(new emp[] {empA});

    depB.setEmp(new emp [] {empB,empC});

    //输出信息

    System.out.println("-------------通过部门获取员工消息---------------");

    for (int i = 0; i < depB.getEmp().length; i++) {
    System.out.println(depB.getEmp()[i].getInfo());

    }

    System.out.println("-------------通过员工获取部门消息---------------");

    System.out.println(empA.getDep().getInfo());

    }

    }

    结果:

    -------------通过部门获取员工消息---------------

    【员工信息】员工编号=10002、员工姓名=王四、员工职业+普通员工

    【员工信息】员工编号=10003、员工姓名=王三、员工职业+管理层员工

    -------------通过员工获取部门消息---------------

    【部门信息】部门编号=财务部、部门名称=财务部

    2、数据库表的一对多映射

    描述:一个父类含有多个子类,一个子类仅有一个父类

    class item{
    private Long iid; //父类ID

    private String iname; //父类名称

    private subitem subitem []; //父类下的多个子类,通过对象数组设计“多”这个概念

    //无参构造方法

    public item() {
    super();

    }

    //有参构造方法

    public item(Long iid, String iname) {
    super();

    this.iid = iid;

    this.iname = iname;

    }

    //getter和setter方法

    public Long getIid() {
    return iid;

    }

    public void setIid(Long iid) {
    this.iid = iid;

    }

    public String getIname() {
    return iname;

    }

    public void setIname(String iname) {
    this.iname = iname;

    }

    public subitem[] getSubitem() {
    return subitem;

    }

    public void setSubitem(subitem[] subitem) {
    this.subitem = subitem;

    }

    public String getInfo() {
    return “【分类信息】分类ID=”+this.getIid()+“分类名称=”+this.getIname();

    }

    }

    class subitem{
    private Long sid;//子类ID

    private String sname;//子类名称

    private item item;//子类所属父类

    //无参构造方法

    public subitem() {
    super();

    }

    //有参构造方法

    public subitem(Long sid, String sname) {
    super();

    this.sid = sid;

    this.sname = sname;

    }

    //setter和getter方法

    public Long getSid() {
    return sid;

    }

    public void setSid(Long sid) {
    this.sid = sid;

    }

    public String getSname() {
    return sname;

    }

    public void setSname(String sname) {
    this.sname = sname;

    }

    public item getItem() {
    return item;

    }

    public void setItem(item item) {
    this.item = item;

    }

    public String getInfo() {
    return “【子类信息】子类ID=”+this.getSid()+“子类名称=”+this.getSname();

    }

    }

    public class javaDamo1 {
    public static void main(String[] args) {
    //实例化多个子类与一个父类

    subitem subitemA=new subitem(20001L,“橘子”);

    subitem subitemB=new subitem(20002L,“苹果”);

    subitem subitemC=new subitem(20003L,“芒果”);

    item item=new item(10001L,“水果”);

    item.setSubitem(new subitem[] {subitemA,subitemB,subitemC});

    subitemA.setItem(item);

    subitemB.setItem(item);

    subitemC.setItem(item);

    System.out.println("-----------------------通过父类查看子类信息-----------------------");

    System.out.println("\t|-父类:"+item.getInfo());

    for (int i = 0; i < item.getSubitem().length; i++) {
    System.out.println("\t\t|-父类的子类信息:"+item.getSubitem()[i].getInfo());

    }

    System.out.println("-----------------------通过子类查看父类信息-----------------------");

    System.out.println("\t|-A子类信息:"+subitemA.getInfo());

    System.out.println("\t\t|-A子类的父类信息:"+subitemA.getItem().getInfo());

    }

    }

    结果:

    -----------------------通过父类查看子类信息-----------------------

    |-父类:【分类信息】分类ID=10001分类名称=水果

    |-父类的子类信息:【子类信息】子类ID=20001子类名称=橘子

    |-父类的子类信息:【子类信息】子类ID=20002子类名称=苹果

    |-父类的子类信息:【子类信息】子类ID=20003子类名称=芒果

    -----------------------通过子类查看父类信息-----------------------

    |-A子类信息:【子类信息】子类ID=20001子类名称=橘子

    |-A子类的父类信息:【分类信息】分类ID=10001分类名称=水果

    3、数据库表的多对多映射

    描述:一个用户可以访问多个商品,一个商品可以被多个用户访问

    问题:

    获取一个用户访问那些商品信息
    获取一个商品被那些用户浏览

    class user{
    private Long uid;//用户ID

    private String uname;//用户名

    private commodity commodity [];//对象数组表示“多”概念

    //无参构造方法

    public user() {
    super();

    }

    //有参数构造方法

    public user(Long uid, String uname) {
    super();

    this.uid = uid;

    this.uname = uname;

    }

    //setter和getter方法

    public Long getUid() {
    return uid;

    }

    public void setUid(Long uid) {
    this.uid = uid;

    }

    public String getUname() {
    return uname;

    }

    public void setUname(String uname) {
    this.uname = uname;

    }

    public commodity[] getCommodity() {
    return commodity;

    }

    public void setCommodity(commodity[] commodity) {
    this.commodity = commodity;

    }

    //获取用户信息

    public String getInfo() {
    return “【用户信息】用户ID=”+this.getUid()+"、用户名="+this.getUname();

    }

    }

    class commodity{
    private Long cid; //商品ID

    private String cname; // 商品名称

    private Double cprice; //商品价格

    private user user[]; //浏览商品的多个用户

    //无参构造方法

    public commodity() {
    super();

    }

    //有参构造方法

    public commodity(Long cid, String cname, Double cprice) {
    super();

    this.cid = cid;

    this.cname = cname;

    this.cprice = cprice;

    }

    //setter和getter方法

    public Long getCid() {
    return cid;

    }

    public void setCid(Long cid) {
    this.cid = cid;

    }

    public String getCname() {
    return cname;

    }

    public void setCname(String cname) {
    this.cname = cname;

    }

    public Double getCprice() {
    return cprice;

    }

    public void setCprice(Double cprice) {
    this.cprice = cprice;

    }

    public user[] getUser() {
    return user;

    }

    public void setUser(user[] user) {
    this.user = user;

    }

    //获取商品信息

    public String getInfo() {
    return “【商品信息】商品ID=”+this.getCid()+"、商品名称="+this.getCname()+"、商品价格="+this.getCprice();

    }

    }

    public class javaDamo2 {
    public static void main(String[] args) {
    //实例化商品与用户

    user userA=new user(1001L,“王五”);

    user userB=new user(1002L,“王四”);

    user userC=new user(1003L,“王三”);

    user userD=new user(1004L,“王二”);

    commodity commodityA=new commodity(1001L, “短袖”, 200.0);

    commodity commodityB=new commodity(1002L, “长裤”, 180.0);

    commodity commodityC=new commodity(1003L, “手机”, 4200.0);

    commodity commodityD=new commodity(1004L, “耳机”, 78.0);

    //一个用户浏览多个商品

    userA.setCommodity( new commodity[] {commodityA,commodityB,commodityC});

    userB.setCommodity( new commodity[] {commodityA,commodityC,commodityD});

    userC.setCommodity( new commodity[] {commodityA,commodityB,commodityC,commodityD});

    userD.setCommodity( new commodity[] {commodityA,commodityB,commodityC,commodityD});

    //一个商品被多个用户浏览

    commodityA.setUser(new user[] {userA,userB,userC,userD});

    commodityB.setUser(new user[] {userA,userC,userD});

    commodityC.setUser(new user[] {userA,userB,userC,userD});

    commodityD.setUser(new user[] {userB,userC,userD});

    //打印信息

    System.out.println("------------------一个用户浏览多个商品----------------");

    System.out.println("\t|-用户A信息"+userA.getInfo());

    for (int i = 0; i < userA.getCommodity().length; i++) {
    System.out.println("\t\t|-用户A浏览商品"+userA.getCommodity()[i].getInfo());

    }

    System.out.println("------------------一个商品被多个用户浏览----------------");

    System.out.println("\t|-商品A信息"+commodityA.getInfo());

    for (int i = 0; i < commodityA.getUser().length; i++) {
    System.out.println("\t\t|-浏览A商品的用户信息"+commodityA.getUser()[i].getInfo());

    }

    }

    }

    结果:

    ------------------一个用户浏览多个商品----------------

    |-用户A信息【用户信息】用户ID=1001、用户名=王五

    |-用户A浏览商品【商品信息】商品ID=1001、商品名称=短袖、商品价格=200.0

    |-用户A浏览商品【商品信息】商品ID=1002、商品名称=长裤、商品价格=180.0

    |-用户A浏览商品【商品信息】商品ID=1003、商品名称=手机、商品价格=4200.0

    ------------------一个商品被多个用户浏览----------------

    |-商品A信息【商品信息】商品ID=1001、商品名称=短袖、商品价格=200.0

    |-浏览A商品的用户信息【用户信息】用户ID=1001、用户名=王五

    |-浏览A商品的用户信息【用户信息】用户ID=1002、用户名=王四

    |-浏览A商品的用户信息【用户信息】用户ID=1003、用户名=王三

    |-浏览A商品的用户信息【用户信息】用户ID=1004、用户名=王二

    4、数据库表的复杂映射

    5、总结:

    主要通过java的引用传递以及对象数组实现数据库标的映射关系。在设计数据库表的映射类时,

    先设计去除外键后的数据库表,之后依据表与表之间的关系完善类。

    展开全文
  • 数据库设计

    2019-09-28 22:24:08
    不同组件所对应的数据库表关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表 结构的重构提供可能性。...

    1) 不应该针对整个系统进行数据库设计,而应该根据系统架构中的组件划分,针对每个组件所处理的业务进行组件单元的数据库设计;不同组件间所对应的数据库表之 间的关联应尽可能减少,如果不同组件间的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表 结构的重构提供可能性。

    2)采用领域模型驱动的方式和自顶向下的思路进行数据库设计,首先分析系统业务,根据职责定义对象。对象要符合封 装的特性,确保与职责相关的数据项被定义在一个对象之内,这些数据项能够完整描述该职责,不会出现职责描述缺失。并且一个对象有且只有一项职责,如果一个 对象要负责两个或两个以上的职责,应进行分拆。

    3)根据建立的领域模型进行数据库表的映射,此时应参考数据库设计第二范式:一个表中的所 有非关键字属性都依赖于整个关键字。关键字可以是一个属性,也可以是多个属性的集合,不论那种方式,都应确保关键字能够保证唯一性。在确定关键字时,应保 证关键字不会参与业务且不会出现更新异常,这时,最优解决方案为采用一个自增数值型属性或一个随机字符串作为表的关键字。

    4)由于第一点所述的领域模型驱动的方式设计数据库表结构,领域模型中的每一个对象只有一项职责,所以对象中的数据项不存在传递依赖,所以,这种思路的数据库表结构设计从一开始即满足第三范式:一个表应满足第二范式,且属性间不存在传递依赖。

    5)同样,由于对象职责的单一性以及对象之间的关系反映的是业务逻辑之间的关系,所以在领域模型中的对象存在主对象和从对象之分,从对象是从1-N 或N-N的角度进一步主对象的业务逻辑,所以从对象及对象关系映射为的表及表关联关系不存在删除和插入异常。

    6) 在映射后得出的数据库表结构中,应再根据第四范式进行进一步修改,确保不存在多值依赖。这时,应根据反向工程的思路反馈给领域模型。如果表结构中存在多值 依赖,则证明领域模型中的对象具有至少两个以上的职责,应根据第一条进行设计修正。第四范式:一个表如果满足BCNF,不应存在多值依赖。

    7) 在经过分析后确认所有的表都满足二、三、四范式的情况下,表和表之间的关联尽量采用弱关联以便于对表字段和表结构的调整和重构。并且,我认为数据库中的表 是用来持久化一个对象实例在特定时间及特定条件下的状态的,只是一个存储介质,所以,表和表之间也不应用强关联来表述业务(数据间的一致性),这一职责应 由系统的逻辑层来保证,这种方式也确保了系统对于不正确数据(脏数据)的兼容性。当然,从整个系统的角度来说我们还是要尽最大努力确保系统不会产生脏数 据,单从另一个角度来说,脏数据的产生在一定程度上也是不可避免的,我们也要保证系统对这种情况的容错性。这是一个折中的方案。

    8)应针 对所有表的主键和外键建立索引,有针对性的(针对一些大数据量和常用检索方式)建立组合属性的索引,提高检索效率。虽然建立索引会消耗部分系统资源,但比 较起在检索时搜索整张表中的数据尤其时表中的数据量较大时所带来的性能影响,以及无索引时的排序操作所带来的性能影响,这种方式仍然是值得提倡的。

    9) 尽量少采用存储过程,目前已经有很多技术可以替代存储过程的功能如“对象/关系映射”等,将数据一致性的保证放在数据库中,无论对于版本控制、开发和部 署、以及数据库的迁移都会带来很大的影响。但不可否认,存储过程具有性能上的优势,所以,当系统可使用的硬件不会得到提升而性能又是非常重要的质量属性 时,可经过平衡考虑选用存储过程。

    10)当处理表间的关联约束所付出的代价(常常是使用性上的代价)超过了保证不会出现修改、删除、更改 异常所付出的代价,并且数据冗余也不是主要的问题时,表设计可以不符合四个范式。四个范式确保了不会出现异常,但也可能由此导致过于纯洁的设计,使得表结 构难于使用,所以在设计时需要进行综合判断,但首先确保符合四个范式,然后再进行精化修正是刚刚进入数据库设计领域时可以采用的最好办法。

    11)设计出的表要具有较好的使用性,主要体现在查询时是否需要关联多张表且还需使用复杂的SQL技巧。

    12)设计出的表要尽可能减少数据冗余,确保数据的准确性,有效的控制冗余有助于提高数据库的性能。

    转载于:https://www.cnblogs.com/Wtingting/p/6541268.html

    展开全文
  • (1)、不应针对整个系统进行...不同组件所对应的数据库表之间的关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表...
  • 不同组件所对应的数据库表之间的关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表结构的重构提供可能性。...
  • 不同组件所对应的数据库表之间的关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表结构的重构提供可能性。
  • 不同组件所对应的数据库表之间的关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表结构的重构提供可能性。...
  • 数据库设计原则

    2017-07-11 11:18:30
    数据库设计规范化的五个要求 一:表中应该避免可为空的列 二:表不应该有重复的值或者列 三:表中记录应该有一个唯一的标识符 四:数据库对象要有统一的前缀名 ...不同 组件所对应的数据库表之间的关联应尽可
  • mysql数据库设计原则

    千次阅读 2016-04-22 23:55:11
    不同组件所对应的数据库表关联应尽可能减少,如果不同组件的表需要外键关联也尽量不要创建外键关联,而只是记录关联表的一个主键,确保组件对应的表之间的独立性,为系统或表 结构的重构提供可能性。 ...
  • 数据库操作

    2018-05-12 13:52:16
    1.1 多之间的关系关联关系:在实际开发中,需要根据实体的内容设计数据,实体会有各种关联关系,所以根据实体设计的数据之间也存在着各种关联关系,MySQL中数据关联关系有三种,具体如下:一对多/多对一多对一...
  • 3.1 设计表间关系:列出父表与子表的关联索引,指出要建立的表间关系的类型。 3.2 完整性设计:列出主要字段完整性的字段名、完整性约束条件;列出记录完整性约束及其约束条件;列出参照完整性表。
  • 数据库设计杂谈

    2013-05-23 11:13:24
    1、数据冗余也包括重复性冗余和派生冗余,重复性冗余一定要避免,杜绝,但是像派生冗余还是提倡的因为它能提高访问的效率。...不同组件所对应的数据库表之间的关联应尽可能减少,如果不同组件
  • 设计和创建表间关系

    2017-04-12 16:13:40
    第 6 节:设计和创建表间关系 在这一课,您将学习如何使用外键来设计和创建表间关系。 有关更多信息,请参阅 " 表是由...数据库中的关系可能表现为表间的外键关系,也可能自身就成 为独立的表。您将在本章中看
  • 数据库设计心得

    2016-07-25 21:56:24
    实体与实体的联系涉及到了是否要创建中间,三种关系分别有一对一,一对多,多对多,一对一的额外属性可以添加于任意一方,一对多的额外属性添加于多的一方,多对多的关系则创建一张关联表(之所以创建关联表是...
  • 一对多:从球队角度来说一个球队拥有多个球员 即为一对多多对一:从球员角度来说多个球员属于一个球队 即为多对一数据表间一对多关系如下图: 多对一关联映射: 场景:用户和组;从用户角度...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 354
精华内容 141
关键字:

数据库表间关联设计