ER图向关系模式转换涉及到两方面：
 ①实体的转换；
 ②实体间联系的转换。
 
 
 
实体的转换：在从ER图转换为关系模式时，一个实体就转换一个关系模式，实体的属性就是关系模式的属性，实体的键就是关系的主键。
实体间联系的转换：实体间存在三种联系，即1:1（一对一）,1:n（一对多），m:n（多对多）。
 
 
在从ER向关系模式转换规则如下：
 ①1:1（一对一）联系
 
 
 
方法一：联系转换为独立的关系模式；模式的属性由联系本身的属性及两个实体的键构成；主键由两个实体中的任意一个键成。
 方法二：联系与一端的实体的关系模式合并，即将联系的属性加入到实体的关系模式内，主键不变。
 
 
②1:n（一对多）联系
 
 
 
方法一：联系转换为独立的关系模式；模式的属性由联系本身的属性及两个实体的键构成；主键由n端实体的键组成。
 方法二：与n端的实体的关系模式合并，即将联系的属性加入到实体的关系模式内，主键不变。
 
 
③m:n（多对多）联系
 
 
 
多对多联系转换成新的独立的模式，模式的属性由联系本身的属性及两个实体的键构成，主键由两端实体的键组合成。
 
 
练习题：
 在一个ER图中，有四个实体集，两个二元一对多联系，两个二元多对多联系，一个三元多对多联系，两个一元多对多联系，则将该ER图转化为关系模型后，得到的关系模式个数是____
 
 
 
答案：
 由题目可知，该题中有4个实体，两个二元一对多联系，两个二元多对多联系，一个三元多对多联系，两个一元多对多联系。4个实体和5个m:n（多对多）联系可以转换为单独的模式，1:n（一对多）联系需要合并到实体中去。因此可以最终得到9个模式。故答案为9。
 

        数据库使用关系建立记录之间的联系。其中，一对多关系是最常用的关系类型，它把一个记录和一组相关的记录联系在一起。实现这种关系时，要在“多”这一侧加入一个外键，指向“一”这一侧联接的记录。大部分的其他关系类型都可以从一对多类型中衍生。 多对一关系从“多”这一侧看，就是一对多关系。 一对一关系类型是简化版的一对多关系， 限制“多”这一侧最多只能有一个记录。唯一不能从一对多关系中简单演化出来的类型是多对多关系，这种关系的两侧都有
多个记录。 
多对多关系
         一对多关系、多对一关系和一对一关系至少都有一侧是单个实体，所以记录之间的联系通过外键实现，让外键指向这个实体。但是，你要如何实现两侧都是“多”的关系呢？
 
        下面以一个典型的多对多关系为例，即一个记录学生和他们所选课程的数据库。很显然，你不能在学生表中加入一个指向课程的外键，因为一个学生可以选择多个课程，一个外键不够用。同样，你也不能在课程表中加入一个指向学生的外键，因为一个课程有多个学生选择。两侧都需要一组外键。这种问题的解决方法是添加第三张表， 这个表称为关联表。现在，多对多关系可以分解成原表和关联表之间的两个一对多关系。
 
下图 描绘了学生和课程之间的多对多关系。
 

 
 
        这个例子中的关联表是 registrations，表中的每一行都表示一个学生注册的一个课程。查询多对多关系要分成两步。 若想知道某位学生选择了哪些课程，你要先从学生和注册之间的一对多关系开始， 获取这位学生在 registrations 表中的所有记录，然后再按照多到一的方向遍历课程和注册之间的一对多关系， 找到这位学生在 registrations 表中各记录
所对应的课程。 同样，若想找到选择了某门课程的所有学生，你要先从课程表中开始，获取其在 registrations 表中的记录，再获取这些记录联接的学生。通过遍历两个关系来获取查询结果的做法听起来有难度， 不过像前例这种简单关系，SQLAlchemy 就可以完成大部分操作。 
上图中的多对多关系使用的代码表示如下：
 

registrations = db.Table('registrations',
    db.Column('student_id', db.Integer, db.ForeignKey('students.id')),
    db.Column('class_id', db.Integer, db.ForeignKey('classes.id'))
)


class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True)
   name = db.Column(db.String)
   classes = db.relationship('Class',secondary=registrations,
                                    backref=db.backref('students', lazy='dynamic'),
                                    lazy='dynamic')


class Class(db.Model):
    id = db.Column(db.Integer, primary_key = True)
    name = db.Column(db.String)

 

         多对多关系仍使用定义一对多关系的 db.relationship() 方法进行定义，但在多对多关系中，必须把 secondary 参数设为关联表。多对多关系可以在任何一个类中定义， backref 参数会处理好关系的另一侧。关联表就是一个简单的表，不是模型，SQLAlchemy 会自动接管这个表。

        这样处理多对多关系特别简单。假设学生是 s，课程是 c，学生注册课程的代码为：

 >>> s.classes.append(c)

 >>> db.session.add(s)

 列出学生 s 注册的课程以及注册了课程 c 的学生也很简单：

 >>> s.classes.all()

 >>> c.students.all()

 Class 模型中的 students 关系由参数 db.backref() 定义。注意，这个关系中还指定了 lazy= 'dynamic' 参数，所以关系两侧返回的查询都可接受额外的过滤器。

 如果后来学生 s 决定不选课程 c 了，那么可使用下面的代码更新数据库：

 >>> s.classes.remove(c)

 
下面来看一个实际的例子：因为在设计中学生会转学院，所以，学生与学院是多对多的关系
 
1.定义模型
 
 

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(100), unique=True, index=True)
    
    .............省略其他字段
    departments=db.relationship('Department', secondary=user_department, backref=db.backref('users',lazy='dynamic'), lazy='dynamic')
    

 
class Department(db.Model):
    __tablename__ = 'departments'
    id = db.Column(db.Integer, primary_key=True)
    department = db.Column(db.String(100))

 
user_department = db.Table('user_department',
    db.Column('user_id', db.Integer, db.ForeignKey('users.id'), primary_key=True),
    db.Column('department_id', db.Integer, db.ForeignKey('departments.id'), primary_key=True)  
)
2.定义表单：
 

class SmForm(Form):
    name = StringField('真实姓名', validators=[Length(0, 64)])
    ....................省略其他字段
    is_departmentChange = BooleanField('是否转过学院')
    pre_department = SelectField('原学院:', coerce=int)
    cut_department = SelectField('现学院：', coerce=int)
    
    submit = SubmitField('Submit')

   #下拉菜单初始化
    def __init__(self, user, *args, **kwargs):
        super(SmForm, self).__init__(*args, **kwargs)
        <strong>self.pre_department.choices = [(pre_department.id, pre_department.department)
                             for pre_department in Department.query.order_by(Department.department).all()]
        self.cut_department.choices = [(cut_department.id, cut_department.department)
                             for cut_department in Department.query.order_by(Department.department).all()]</strong>
       
        self.user = user
3.定义路由：
 

@main.route('/sm', methods=['GET', 'POST'])
@login_required
@main.errorhandler(404)
def sm():
    user = User.query.filter_by(email=current_user.email).first()
    form = SmForm(user)
    if  user.is_realname ==False:
        if form.validate_on_submit():

            # User的学院更新  删除旧的数据，<strong>联合删除
            usr = current_user._get_current_object()
            deparment = user.departments.all()
            for de in deparment:
                de.users.remove(usr)</strong>

       ........................省略其他

            
            user.is_departmentChange = form.is_departmentChange.data
          <strong>#向关系表中添加
            user.departments.append(Department.query.get(form.pre_department.data))
            user.departments.append(Department.query.get(form.cut_department.data))

            db.session.add(user)
            db.session.commit()</strong>
            return redirect(url_for('.sm_success'))
    return render_template('sm.html', form=form)
4.渲染模板（省略）

 

 
 

 

层次数据模型
 
    定义：层次数据模型是用树状<层次>结构来组织数据的数据模型。
 
    满足下面两个条件的基本层次联系的集合为层次模型
     1. 有且只有一个结点没有双亲结点，这个结点称为根结点
     2. 根以外的其它结点有且只有一个双亲结点
 
其实层次数据模型就是的图形表示就是一个倒立生长的树，由基本数据结构中的树（或者二叉树）的定义可知，每棵树都有且仅有一个根节点，其余的节点都是非根节点。每个节点表示一个记录类型对应与实体的概念，记录类型的各个字段对应实体的各个属性。各个记录类型及其字段都必须记录。
 　　
 　　层次模型的特点：
     结点的双亲是唯一的
     只能直接处理一对多的实体联系
     每个记录类型可以定义一个排序字段，也称为码字段
     任何记录值只有按其路径查看时，才能显出它的全部意义
     没有一个子女记录值能够脱离双亲记录值而独立存在
 　　实例：
 　　　　
 　　　　
 　　　　
     层次模型的完整性约束条件
     无相应的双亲结点值就不能插入子女结点值
     如果删除双亲结点值，则相应的子女结点值也被同时删除
     更新操作时，应更新所有相应记录，以保证数据的一致性
 
    优点
     层次模型的数据结构比较简单清晰
     查询效率高，性能优于关系模型，不低于网状模型
     层次数据模型提供了良好的完整性支持
     缺点
     结点之间的多对多联系表示不自然
     对插入和删除操作的限制多，应用程序的编写比较复杂
     查询子女结点必须通过双亲结点
     层次命令趋于程序化
 
层次数据库系统的典型代表是IBM公司的IMS（Information Management System）数据库管理系统
 

 
网状数据模型
 
    定义：用有向图表示实体和实体之间的联系的数据结构模型称为网状数据模型。
     满足下面两个条件的基本层次联系的集合称为网状数据模型：
     1. 允许一个以上的结点无双亲；
     2. 一个结点可以有多于一个的双亲。
 
 　　其实，网状数据模型可以看做是放松层次数据模型的约束性的一种扩展。网状数据模型中所有的节点允许脱离父节点而存在，也就是说说在整个模型中允许存在两个或多个没有根节点的节点，同时也允许一个节点存在一个或者多个的父节点，成为一种网状的有向图。因此节点之间的对应关系不再是1:n，而是一种m:n的关系，从而克服了层次状数据模型的缺点。
 　　特征：
 　　　　 1. 可以存在两个或者多个节点没有父节点；
 　　　　 2. 允许单个节点存在多于一个父节点；
 　　网状数据模型中的，每个节点表示一个实体，节点之间的有向线段表示实体之间的联系。网状数据模型中需要为每个联系指定对应的名称。
 　　实例：　　
 
 
    优点：
     网状数据模型可以很方便的表示现实世界中的很多复杂的关系；
     修改网状数据模型时，没有层次状数据模型的那么多的严格限制，可以删除一个节点的父节点而依旧保留该节点；也允许插入一个没有任何父节点的节点，这样的插入在层次状数据模型中是不被允许的，除非是首先插入的是根节点；
     实体之间的关系在底层中可以借由指针指针实现，因此在这种数据库中的执行操作的效率较高；
 
    缺点：
      网状数据模型的结构复杂，使用不易，随着应用环境的扩大，数据结构越来越复杂，数据的插入、删除牵动的相关数据太多，不利于数据库的维护和重建。
      网状数据模型数据之间的彼此关联比较大，该模型其实一种导航式的数据模型结构，不仅要说明要对数据做些什么，还说明操作的记录的路径；
     DDL、DML语言复杂，用户不容易使用
     记录之间联系是通过存取路径实现的，用户必须了解系统结构的细节
 
    网状模型与层次模型的区别
     网状模型允许多个结点没有双亲结点
     网状模型允许结点有多个双亲结点
     网状模型允许两个结点之间有多种联系（复合联系）
     网状模型可以更直接地描述现实世界
     层次模型实际上是网状模型的一个特例
 
典型代表是DBTG系统，亦称CODASYL系统，是20世纪70年代由DBTG提出的一个系统方案。实际系统：Cullinet Software公司的 IDMS、Univac公司的 DMS1100、Honeywell公司的IDS/2、HP公司的IMAGE。
 

 
三、关系型数据模型
 　　关系型数据模型对应的数据库自然就是关系型数据库了，这是目前应用最多的数据库。
 　　定义：使用表格表示实体和实体之间关系的数据模型称之为关系数据模型。
 　　关系型数据库是目前最流行的数据库，同时也是被普遍使用的数据库，如MySQL就是一种流行的数据库。支持关系数据模型的数据库管理系统称为关系型数据库管理系统。
 　　特征：
 　　　　 1. 关系数据模型中，无论是是实体、还是实体之间的联系都是被映射成统一的关系—一张二维表，在关系模型中，操作的对象和结果都是一张二维表，它由行和列组成；
 　　　　 2. 关系型数据库可用于表示实体之间的多对多的关系，只是此时要借助第三个关系—表，来实现多对多的关系；
 　　　　 3. 关系必须是规范化的关系，即每个属性是不可分割的实体，不允许表中表的存在；
 　　实例：
 
 
    优点：
      结构简单，关系数据模型是一些表格的框架，实体的属性是表格中列的条目，实体之间的关系也是通过表格的公共属性表示，结构简单明了；
     关系数据模型中的存取路径对用户而言是完全隐蔽的，是程序和数据具有高度的独立性，其数据语言的非过程化程度较高；
     操作方便，在关系数据模型中操作的基本对象是集合而不是某一个元祖；
      有坚实的数学理论做基础，包括逻辑计算、数学计算等；
 
    缺点：
     查询效率低，关系数据模型提供了较高的数据独立性和非过程化的查询功能（查询的时候只需指明数据存在的表和需要的数据所在的列，不用指明具体的查找路径），因此加大了系统的负担；
     由于查询效率较低，因此需要数据库管理系统对查询进行优化，加大了DBMS的负担；
 
    相关概念：
     关系（Relation）：一个关系对应通常说的一张表
     元组（Tuple）：表中的一行即为一个元组
     属性（Attribute）：表中的一列即为一个属性，给每一个属性起一个名称即属性名
     主码（Key）：也称码键。表中的某个属性组，它可以唯一确定一个元组
     域（Domain）：是一组具有相同数据类型的值的集合。属性的取值范围来自某个域。
     分量：元组中的一个属性值。
     关系模式：对关系的描述，关系名（属性1，属性2，…，属性n），如：学生（学号，姓名，年龄，性别，系名，年级）
 
    关系必须是规范化的，满足一定的规范条件
     最基本的规范条件：关系的每一个分量必须是一个不可分的数据项, 不允许表中还有表
 
    术语对比
 
 
    关系的完整性约束条件
     实体完整性
     实体完整性是指实体的主属性不能取空值。实体完整性规则规定实体的所有主属性都不能为空。实体完整性针对基本关系而言的，一个基本关系对应着现实世界中的一个主题，例如上例中的学生表对应着学生这个实体。现实世界中的实体是可以区分的，他们具有某种唯一性标志，这种标志在关系模型中称之为主码，主码的属性也就是主属性不能为空。
     参照完整性
     在关系数据库中主要是值得外键参照的完整性。若A关系中的某个或者某些属性参照B或其他几个关系中的属性，那么在关系A中该属性要么为空，要么必须出现B或者其他的关系的对应属性中。
     用户定义的完整性
     用户定义完整性是针对某一个具体关系的约束条件。它反映的某一个具体应用所对应的数据必须满足一定的约束条件。例如，某些属性必须取唯一值，某些值的范围为0-100等。
 
计算机厂商新推出的数据库管理系统几乎都支持关系模型
 

 

spring-boot ，spring-data-jpa 关系映射关系，实现一对多，多对多，一对一
 
仅仅展示代码，不需要太多的其他无用字眼
 
1：多对多
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)   //多对多
    @JoinTable(					//jointable。维护方加此注释
            name="tyg_user_role",		//name是表名，
//joincolumns需要将此entity中的什么字段添加到表的什么字段，name是存储在多对多关系表中的字段名，referencedColumnName为此外键
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
//inverseJoinColumns,name字段是关系entity Role的id以role_id存储在关系表tyg_user_role中
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;


@Entity
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String roleName;
    private String roleDes;
//多对多不维护的一方属性，只写mappedBy，值和维护方的属性值一致
    @ManyToMany(mappedBy = "roles")
    private List<User> users;

2.一对多
	一方
@Entity//标注为一个实体
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
            name="tyg_user_role",
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;

//标注一对多，此处的cascadeType值得说明
//PERSIST新增，保存级联操作、MERGE更新级联操作、REFRESH刷新级联操作、REMOVE删除级联操作
    @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH },fetch = FetchType.LAZY)

//多的一方维护的列，foreignKey实际为索引值，并不是外兼值
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "uId", value =ConstraintMode.CONSTRAINT))
    private List<MyOrder> myOrders;
	多方
@Entity
public class MyOrder{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String code;
    private Double total;
    
    @ManyToOne(fetch = FetchType.LAZY,cascade = CascadeType.ALL)
    @JoinColumn(name = "uId",foreignKey = @ForeignKey(name = "uId"))
    private User user;

3、一对一

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String reallName;
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
            name="tyg_user_role",
            joinColumns={@JoinColumn(name="user_id", referencedColumnName="ID")},
            inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="ID")})
    private List<Role> roles;

    @OneToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH },fetch = FetchType.LAZY)
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "uId", value =ConstraintMode.CONSTRAINT))
    private List<MyOrder> myOrders;

//此处比较多的坑，级联操作使用不当，就会报错，当只维护cId的时候，去除级联PERSIST
    @OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH }, fetch = FetchType.LAZY)
    @org.hibernate.annotations.ForeignKey(name = "none")
    @JoinColumn(name = "cId", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT))
    private Customer customer;


@Entity
//@Data
//@AllArgsConstructor
//@NoArgsConstructor
@NamedQuery(name="Customer.findByFirstName",query = "select c from Customer c where c.firstName = ?1")
public class Customer {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    private String firstName;
    private String lastName;

    //一对一
//此处比较多的坑，级联操作使用不当，就会报错，当只维护cId的时候，去除级联PERSIST，如下
    @OneToOne(cascade = { CascadeType.REFRESH }, fetch = FetchType.LAZY)
    @JoinColumn(name = "uId", foreignKey = @ForeignKey(name = "none", value = ConstraintMode.NO_CONSTRAINT))
    private User user;

 
有问题可以向我提问，可能不会随时回，但是看到的话会回复的。仅仅是初级，写的不好勿喷，请指教！