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 语句，应用到接下来所有的代章节中：

?
1
2
3
4
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() 方法来引用子表的类：

?
1
2
3
4
5
6
7
8
9
10
11
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 方法参数：

?
1
2
3
4
5
6
7
8
9
10
11
12
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 参数：

?
1
2
3
4
5
6
7
8
9
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:

?
1
2
3
4
5
6
7
8
9
10
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:

?
1
2
3
4
5
6
7
8
9
10
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:

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

?
1
2
3
4
5
6
7
8
9
10
11
12 
from sqlalchemy.orm import backrefclass 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))

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准则，还是推荐将中间关系写成类。

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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 "<Groupobject: 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 "<UserProfileobject: 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 "<HostUserobject: id=%s, host_id=%s, username=%s>" %(self.id, self.host_id, self.username)

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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 "<Groupobject: 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 "<UserProfileobject: 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 "<HostUserobject: 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:

?
1
2
3
4
5
6
7
8
9
10
11
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:

?
1
2
3
4
5
6
7
8
9
10
11
12
from sqlalchemy import Integer, ForeignKey, String, Column <br>from sqlalchemy.ext.declarative import declarative_base <br>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相关的源码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)

?
1
2
3
4
5
6
7
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.

转载于:https://www.cnblogs.com/wxzbk/p/10499534.html

SQLAlchemy_定义(一对一/一对多/多对多)关系相关推荐

  1. 数据库一对一 一对多 多对多关系

    参考:https://blog.csdn.net/u013144287/article/details/79024130 自己在项目中写的实例: '实体'和'公理'具有多对多关系,即一个实体可以对应多 ...

  2. Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作

    Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作,单表查询,多表查询 一丶表与表之间的关系 背景: ​ ​ ​  ​ ​ 由于如果只使用一张表存储所有的数据,就会操作数 ...

  3. 7. MyBatis多表查询 - 一对一 - 一对多 - 多对多

    7. MyBatis多表查询 - 一对一 - 一对多 - 多对多 前言 在前面的篇章,我们已经熟悉了单表查询,下面我们来看看如何进行 多表查询. 数据准备 create database if not ...

  4. mybatis的一对一 一对多 多对多

    mybatis的一对一 一对多 多对多 1.表 2.建表语句 order_t表 CREATE TABLE `order_t` ( `id` int(11) NOT NULL, `user_id` in ...

  5. day 69-70 一对一 一对多 多对一联表查询

    day 69 orm操作之表关系,多对多,多对一多对一/一对多,多对多{类中的定义方法}day691. 昨日内容回顾1. 单表增删改查2. 单表查询API返回QuerySet对象的:1. .all() ...

  6. JPA 一对一 一对多 多对一 多对多配置

    1 JPA概述 1.1 JPA是什么 JPA (Java Persistence API) Java持久化API.是一套Sun公司 Java官方制定的ORM 方案,是规范,是标准 ,sun公司自己并没 ...

  7. Django一对一 ,一对多,多对多

    Django 数据库一对多,多对多 目录 app01/models.py app01/views.py app01/urls.py Python_Django/urls.py 目录 app01/mod ...

  8. 数据库外键:一对多/多对多关系

    数据库事务四大特性ACID: 原子性(Atomicity) 一致性(Consistency) 隔离性(Isolation) 持久性(Durability) 基于原子性对存在重复数据的表进行拆分 一对多 ...

  9. Hibernate一对多/多对一关系映射详解及相应的增删查改操作

    以客户与订单的关系为例 1.在实体模型类中绑定两者关系: 客户类: public class Customer {private Integer id;//客户idprivate String nam ...

最新文章

  1. 黑盒测试方法之等价类划分法
  2. connect() failed (111: Connection refused) while connecting to upstream, cli
  3. Python中import导入上一级目录模块及循环import问题的解决
  4. 从零开始学习jQuery (九) jQuery工具函数 【转】
  5. Python二级笔记（6）
  6. Linux的errno
  7. html5动画测试题,Html5+js测试题
  8. 技嘉GA7PESH3主板，官网驱动下载，官方使用说明
  9. jQuery放大镜插件
  10. FANUC NC GUIDE PRO 17.1虚拟机（XP系统）
  11. Javassist简介
  12. JAVA POI 对excel加密后 无法打开的解决办法
  13. wps中vbe6ext.olb不能被加载问题（附WPS2019宏下载）
  14. 网易设计师：交互设计要承担的8大工作职能
  15. 中荷人寿山东省分公司开展保险消费者权益保护教育宣传周活动
  16. 学习笔记2-了解unik的设计
  17. Json：前台对象数组传到后台解析
  18. Redirect 重定向
  19. js 原子级操作_原子操作与同步机制
  20. MySQL数据库之约束

热门文章

  1. select下拉框兼容写法
  2. Y1ng‘s BabyCode
  3. Centos下本地连接postgresql时出现认证错误的问题
  4. Factorial Trailing Zeroes
  5. 1.3.3 激活函数介绍
  6. ML---Simple Linear Regression
  7. quartz与c3p0冲突
  8. wamp解决ajax跨域问题
  9. 1.什么是数据化运营——《数据挖掘与数据化运营实战》
  10. 【转载】表单中 Readonly 和 Disabled 的区别