python-复盘-flask-数据库一对一／一对多／多对多关系

Flask 数据库多对多关系

实现学生与学院之间的多对多关系

这个例子中的关联表是 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.渲染模板（省略）

SQLAlchemy_定义(一对一/一对多/多对多)关系

基本关系模式

from sqlalchemy import Table, Column, Integer, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

One To Many

表示一对多的关系时，在子表类中通过 foreign key (外键)引用父表类。
然后，在父表类中通过 relationship() 方法来引用子表的类：

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship("Child")
   # 在父表类中通过 relationship() 方法来引用子表的类集合

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    # 在子表类中通过` foreign key` (外键)引用父表的参考字段

在一对多的关系中建立双向的关系，这样的话在对方看来这就是一个多对一的关系
在子表类中附加一个 relationship() 方法，并且在双方的 relationship() 方法中使用relationship.back_populates 方法参数:

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship("Child", back_populates="parent")

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    parent = relationship("Parent", back_populates="children")
    # 子表类中附加一个 relationship() 方法
    # 并且在(父)子表类的 relationship() 方法中使用 relationship.back_populates 参数

这样的话子表将会在多对一的关系中获得父表的属性
或者，可以在单一的 relationship() 方法中使用 backref 参数来代替 back_populates 参数：

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    children = relationship("Child", backref="parent")

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))

One To One

一对一是两张表之间本质上的双向关系
要做到这一点，只需要在一对多关系基础上的父表中使用 uselist 参数来表示
To convert one-to-many into one-to-one:

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    child = relationship("Child", uselist=False, back_populates="parent")

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    parent = relationship("Parent", back_populates="child")

To convert many-to-one into one-to-one:

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    child_id = Column(Integer, ForeignKey('child.id'))
    child = relationship("Child", back_populates="parent")

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent = relationship("Parent", back_populates="child", uselist=False)

同样的，可以使用下面这种方式:

from sqlalchemy.orm import backref

class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    child_id = Column(Integer, ForeignKey('child.id'))
    child = relationship("Child", backref=backref("parent", uselist=False))

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))

Many To Many

多对多关系会在两个类之间增加一个关联的表。这个关联的表在 relationship() 方法中通过 secondary 参数来表示。
通常的，这个表会通过 MetaData 对象来与声明基类关联，所以这个 ForeignKey 指令会使用链接来定位到远程的表：

# 多对多关系中的两个表之间的一个关联表
association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id')),
    Column('right_id', Integer, ForeignKey('right.id'))
)

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship("Child",
                    secondary=association_table)
    # 在父表中的 relationship() 方法传入 secondary 参数，其值为关联表的表名

class Child(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)

双向关系中，两个表类都会包含这个集合。指定使用 relationship.back_populates参数，并且为每一个 relationship()方法指定共用的关联表：

association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id')),
    Column('right_id', Integer, ForeignKey('right.id'))
)

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship(
        "Child",
        secondary=association_table,
        back_populates="parents")

class Child(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)
    parents = relationship(
        "Parent",
        secondary=association_table,
        back_populates="children")

当在父表类的 relationship()方法中使用backref参数代替 relationship.back_populates 时，backref 会自动的为子表类加载同样的 secondary 参数。

association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id')),
    Column('right_id', Integer, ForeignKey('right.id'))
)

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship("Child",
                    secondary=association_table,
                    backref="parents")

class Child(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)

secondary 参数还能够接收一个可调函数的最终返回值，

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship("Child",
                    secondary=lambda: association_table,
                    backref="parents")

class Parent(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    children = relationship("Child",
                    secondary="association",
                    backref="parents")

参考