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

• 目录
• Basic Relationship Patterns
• One To Many
• One To One
• Many To Many

Basic Relationship Patterns

基本关系模式 
The imports used for each of the following sections is as follows: 
下列的 import 语句，应用到接下来所有的代章节中：

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

A one to many relationship places a foreign key on the child table referencing the parent. 
表示一对多的关系时，在子表类中通过 foreign key (外键)引用父表类。 
relationship() is then specified on the parent, as referencing a collection of items represented by the child: 
然后，在父表类中通过 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 (外键)引用父表的参考字段

 To establish a bidirectional relationship in one-to-many, where the “reverse” side is a many to one, 
在一对多的关系中建立双向的关系，这样的话在对方看来这就是一个多对一的关系， 
specify an additional relationship() and connect the two using the relationship.back_populates parameter: 
在子表类中附加一个 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 参数

 Child will get a parent attribute with many-to-one semantics. 
这样的话子表将会在多对一的关系中获得父表的属性

Alternatively, the backref option may be used on a single relationship() instead of using 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

One To One is essentially a bidirectional relationship with a scalar attribute on both sides. 
一对一是两张表之间本质上的双向关系。 
To achieve this, the uselist flag indicates the placement of a scalar attribute instead of a collection on the “many” side of the relationship. 
要做到这一点，只需要在一对多关系基础上的父表中使用 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)

 As always, the relationship.backref and backref() functions may be used in lieu of the relationship.back_populates approach; to specifyuselist on a backref, use the backref() function:

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

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

Many to Many adds an association table between two classes. 
多对多关系会在两个类之间增加一个关联的表。 
The association table is indicated by the secondary argument to relationship(). 
这个关联的表在 relationship() 方法中通过 secondary 参数来表示。 
Usually, the Table uses the MetaData object associated with the declarative base class, 
通常的，这个表会通过 MetaData 对象来与声明基类关联， 
so that the ForeignKey directives can locate the remote tables with which to link: 
所以这个 ForeignKey 指令会使用链接来定位到远程的表：

定义中间表可以定义中间关系表相关的类，也可以直接通过Base.metdata生成对应关系表对象，不过基于code first准则，还是推荐将中间关系写成类。

构建第三张关系类实现多对多。

Base = declarative_base() #生成sqlorm基础类


class HostUserToGroup(Base):
    __tablename__ = 'hostuser_to_group' # 表名hostuser_to_group
    nid = Column(Integer, primary_key=True,autoincrement=True)
    hostuser_id = Column(Integer,ForeignKey('host_user.id'),primary_key=True)# 外键关联host_user表的id字段
    group_id = Column(Integer,ForeignKey('group.id'),primary_key=True) # 外键关联group表的id字段




class UserProfileToGroup(Base):
    __tablename__ = 'userprofile_to_group'# 表名userprofile_to_group
    nid = Column(Integer, primary_key=True,autoincrement=True)
    userprofile_id = Column(Integer,ForeignKey('user_profile.id'),primary_key=True)# 外键关联user_profile表的id字段
    group_id = Column(Integer,ForeignKey('group.id'),primary_key=True)# 外键关联group表的id字段


class UserProfileToHostUser(Base):
    __tablename__ = 'userprofile_to_hostuser'# 表名userprofile_to_hostuser
    nid = Column(Integer, primary_key=True,autoincrement=True)
    userprofile_id = Column(Integer,ForeignKey('user_profile.id'),primary_key=True)# 外键关联user_profile表的id字段
    hostuser_id = Column(Integer,ForeignKey('host_user.id'),primary_key=True)# 外键关联host_user表的id字段

class Host(Base):
    __tablename__ = 'host' #表名host
    id = Column(Integer, primary_key= True, autoincrement= True)# id字段，主键，自动增长
    hostname = Column(String(64),unique= True,nullable= False)# hostname字段，唯一，不能为空
    ip_addr = Column(String(64),unique= True,nullable= False)#ip_addr字段，唯一，不能为空
    port = Column(Integer, default = 22) # port字段，整形，默认22
    def __repr__(self):
        return "<Hostobject: id=%s, hostname=%s, ip_addr=%s, port=%s>" %(self.id, self.hostname, self.ip_addr, self.port)

class Group(Base):
    __tablename__ = 'group' # 表名group
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    name = Column(String(64), unique = True, nullable = False) # name字段，唯一，不为空
    def __repr__(self):
        return "<Group object: id=%s, name=%s>" %(self.id, self.name)

class UserProfile(Base):
    __tablename__ = 'user_profile' # 表名user_profile
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    username = Column(String(64), unique = True, nullable = False) # username字段，唯一，不为空
    password = Column(String(255), nullable = False) # password字段，不为空
    hostusers = relationship('HostUser', secondary = UserProfileToHostUser.__tablename__, backref = 'user_profiles') # 多对多关联HostUser表类（注意不是表名），中间表类UserProfileToHostUser（注意不是表名），反向字段为user_profiles
    groups = relationship('Group', secondary = UserProfileToGroup.__tablename__, backref = 'user_profiles') # 多对多关联Group表类（注意不是表名），中间表类UserProfileToGroup（注意不是表名），反向字段为user_profiles

    def __repr__(self):
        return "<UserProfile object: id=%s, username=%s>" %(self.id, self.username)

class HostUser(Base):
    __tablename__ = 'host_user' # 表名host_user
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    host_id = Column(Integer, ForeignKey('host.id')) # host_id，外键关联host表的id字段
    AuthTypes = [
        (u'ssh-password', u'SSH/Password'),
        (u'ssh-key', u'SSH/Key'),
    ] # 选项列表
    auth_type = Column(ChoiceType(AuthTypes)) # auth_type字段，只能是选项列表里规定的值
    username = Column(String(64), nullable = True) # username字段，不为空
    password = Column(String(255)) # password字段
    host = relationship('Host', backref = 'host_users')
    groups = relationship('Group', secondary = HostUserToGroup.__tablename__, backref = 'host_users') # 多对多关联Group表类（注意不是表名），中间表类HostUserToGroup（注意不是表名），反向字段为host_users
    __table_args = (UniqueConstraint('host_id', 'username', name = '_host_username_uc')) # host_id和username组成联合唯一约束

    def __repr__(self):
        return "<HostUser object: id=%s, host_id=%s, username=%s>" %(self.id, self.host_id, self.username)

构建关系表实现多对多实例如下：

from sqlalchemy import create_engine,and_,or_,func,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,
    ForeignKey, UniqueConstraint, DateTime
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy_utils import ChoiceType,PasswordType
from datetime import datetime

Base = declarative_base() #生成sqlorm基础类

HostUserToGroup = Table('hostuser_to_group', Base.metadata,  # 表名hostuser_to_group
    Column('hostuser_id', ForeignKey('host_user.id'), primary_key = True), # 外键关联host_user表的id字段
    Column('group_id', ForeignKey('group.id'), primary_key = True), # 外键关联group表的id字段
)

UserProfileToGroup = Table('userprofile_to_group', Base.metadata, # 表名userprofile_to_group
    Column('userprofile_id', ForeignKey('user_profile.id'), primary_key = True), # 外键关联user_profile表的id字段
    Column('group_id', ForeignKey('group.id'), primary_key = True), # 外键关联group表的id字段
)

UserProfileToHostUser = Table('userprofile_to_hostuser', Base.metadata, # 表名userprofile_to_hostuser
    Column('userprofile_id', ForeignKey('user_profile.id'), primary_key = True), # 外键关联user_profile表的id字段
    Column('hostuser_id', ForeignKey('host_user.id'), primary_key = True), # 外键关联host_user表的id字段
)

class Host(Base):
    __tablename__ = 'host' #表名host
    id = Column(Integer, primary_key= True, autoincrement= True)# id字段，主键，自动增长
    hostname = Column(String(64),unique= True,nullable= False)# hostname字段，唯一，不能为空
    ip_addr = Column(String(64),unique= True,nullable= False)#ip_addr字段，唯一，不能为空
    port = Column(Integer, default = 22) # port字段，整形，默认22
    def __repr__(self):
        return "<Hostobject: id=%s, hostname=%s, ip_addr=%s, port=%s>" %(self.id, self.hostname, self.ip_addr, self.port)

class Group(Base):
    __tablename__ = 'group' # 表名group
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    name = Column(String(64), unique = True, nullable = False) # name字段，唯一，不为空
    def __repr__(self):
        return "<Group object: id=%s, name=%s>" %(self.id, self.name)

class UserProfile(Base):
    __tablename__ = 'user_profile' # 表名user_profile
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    username = Column(String(64), unique = True, nullable = False) # username字段，唯一，不为空
    password = Column(String(255), nullable = False) # password字段，不为空
    hostusers = relationship('HostUser', secondary = UserProfileToHostUser, backref = 'user_profiles') # 多对多关联HostUser表类（注意不是表名），中间表类UserProfileToHostUser（注意不是表名），反向字段为user_profiles
    groups = relationship('Group', secondary = UserProfileToGroup, backref = 'user_profiles') # 多对多关联Group表类（注意不是表名），中间表类UserProfileToGroup（注意不是表名），反向字段为user_profiles

    def __repr__(self):
        return "<UserProfile object: id=%s, username=%s>" %(self.id, self.username)

class HostUser(Base):
    __tablename__ = 'host_user' # 表名host_user
    id = Column(Integer, primary_key = True) # id字段，主键，自动增长
    host_id = Column(Integer, ForeignKey('host.id')) # host_id，外键关联host表的id字段
    AuthTypes = [
        (u'ssh-password', u'SSH/Password'),
        (u'ssh-key', u'SSH/Key'),
    ] # 选项列表
    auth_type = Column(ChoiceType(AuthTypes)) # auth_type字段，只能是选项列表里规定的值
    username = Column(String(64), nullable = True) # username字段，不为空
    password = Column(String(255)) # password字段
    host = relationship('Host', backref = 'host_users')
    groups = relationship('Group', secondary = HostUserToGroup, backref = 'host_users') # 多对多关联Group表类（注意不是表名），中间表类HostUserToGroup（注意不是表名），反向字段为host_users
    __table_args = (UniqueConstraint('host_id', 'username', name = '_host_username_uc')) # host_id和username组成联合唯一约束

    def __repr__(self):
        return "<HostUser object: id=%s, host_id=%s, username=%s>" %(self.id, self.host_id, self.username)

Linking Relationships with Backref 

简单来说, relationship函数是sqlalchemy对关系之间提供的一种便利的调用方式, backref参数则对关系提供反向引用的声明。

The backref keyword argument was first introduced in Object Relational Tutorial, and has been mentioned through- out many of the examples here. What does it actually do ? Let’s start with the canonical User and Address scenario: 

from sqlalchemy import Integer, ForeignKey, String, Column from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship
Base = declarative_base()
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True) name = Column(String)
    addresses = relationship("Address", backref="user")
class Address(Base):
__tablename__ = 'address'
id = Column(Integer, primary_key=True)
email = Column(String)
user_id = Column(Integer, ForeignKey('user.id'))

The above configuration establishes a collection of Address objects on User called User.addresses. It also establishes a .user attribute on Address which will refer to the parent User object.

In fact, the backref keyword is only a common shortcut for placing a second relationship() onto the Address mapping, including the establishment of an event listener on both sides which will mirror attribute op- erations in both directions. The above configuration is equivalent to: 

from sqlalchemy import Integer, ForeignKey, String, Column 
from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy.orm import relationship
Base = declarative_base()
class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True) name = Column(String)
    addresses = relationship("Address", back_populates="user")
class Address(Base): 
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    email = Column(String)
    user_id = Column(Integer, ForeignKey('user.id'))
    user = relationship("User", back_populates="addresses")

Above, we add a .user relationship to Address explicitly. On both relationships, the back_populates directive tells each relationship about the other one, indicating that they should establish “bidirectional” behavior between each other. The primary effect of this configuration is that the relationship adds event handlers to both attributes which have the behavior of “when an append or set event occurs here, set ourselves onto the incoming attribute using this particular attribute name”. The behavior is illustrated as follows. Start with a User and an Address instance. The .addresses collection is empty, and the .user attribute is None: 

下面来看下backref相关的源码

def backref(name, **kwargs):
    """Create a back reference with explicit keyword arguments, which are     the same arguments one can send to :func:`relationship`.

    Used with the ``backref`` keyword argument to :func:`relationship` in
    place of a string argument, e.g.::

        'items':relationship(
            SomeItem, backref=backref('parent', lazy='subquery'))

    .. seealso::

        :ref:`relationships_backref`

    """

    return (name, kwargs)

param backref:
          indicates the string name of a property to be placed on the related
          mapper's class that will handle this relationship in the other
          direction. The other property will be created automatically
          when the mappers are configured.  Can also be passed as a
          :func:`.backref` object to control the configuration of the
          new relationship.