如何使用SQLAlchemy的ORM模式构建表结构：一对一、一对多和多对多的关系

如何使用SQLAlchemy的ORM模式构建表结构：一对一、一对多和多对多的关系

引用

CSDN

1.

https://m.blog.csdn.net/qq_52964132/article/details/145483952

在 SQLAlchemy 的 ORM 模式中，可以通过定义类和关系来构建表结构，实现一对一、一对多和多对多的关系。以下是具体的实现方式：

1. 一对一关系（One-to-One）

一对一关系是指一个记录与另一个记录之间存在唯一对应关系。在 SQLAlchemy 中，可以通过 relationship 和 uselist=False 来实现。

示例代码

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker

Base = declarative_base()

class Person(Base):
    __tablename__ = 'persons'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    # 定义一对一关系
    passport = relationship("Passport", uselist=False, back_populates="person")

class Passport(Base):
    __tablename__ = 'passports'
    id = Column(Integer, primary_key=True)
    passport_number = Column(String)
    person_id = Column(Integer, ForeignKey('persons.id'))
    # 反向引用
    person = relationship("Person", back_populates="passport")

# 创建数据库引擎和会话
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 添加数据
person = Person(name="Alice")
passport = Passport(passport_number="123456789")
person.passport = passport
session.add(person)
session.commit()

# 查询
person = session.query(Person).first()
print(person.name, person.passport.passport_number)

2. 一对多关系（One-to-Many）

一对多关系是指一个记录可以与多个记录相关联。在 SQLAlchemy 中，可以通过 relationship 和 ForeignKey 来实现。

示例代码

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker

Base = declarative_base()

class Parent(Base):
    __tablename__ = 'parents'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    # 定义一对多关系
    children = relationship("Child", back_populates="parent")

class Child(Base):
    __tablename__ = 'children'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    parent_id = Column(Integer, ForeignKey('parents.id'))
    # 反向引用
    parent = relationship("Parent", back_populates="children")

# 创建数据库引擎和会话
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 添加数据
parent = Parent(name="John")
child1 = Child(name="Alice")
child2 = Child(name="Bob")
parent.children.append(child1)
parent.children.append(child2)
session.add(parent)
session.commit()

# 查询
parent = session.query(Parent).first()
for child in parent.children:
    print(parent.name, child.name)

3. 多对多关系（Many-to-Many）

多对多关系是指多个记录可以与多个记录相关联。在 SQLAlchemy 中，需要通过一个关联表来实现。

示例代码

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

Base = declarative_base()

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

class Left(Base):
    __tablename__ = 'left'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    # 定义多对多关系
    rights = relationship("Right", secondary=association_table, back_populates="lefts")

class Right(Base):
    __tablename__ = 'right'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    # 反向引用
    lefts = relationship("Left", secondary=association_table, back_populates="rights")

# 创建数据库引擎和会话
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 添加数据
left1 = Left(name="Left1")
left2 = Left(name="Left2")
right1 = Right(name="Right1")
right2 = Right(name="Right2")
left1.rights.append(right1)
left1.rights.append(right2)
left2.rights.append(right1)
session.add_all([left1, left2, right1, right2])
session.commit()

# 查询
left = session.query(Left).first()
for right in left.rights:
    print(left.name, right.name)

总结

• 一对一：通过 relationship 和 uselist=False 实现。
• 一对多：通过 relationship 和 ForeignKey 实现。
• 多对多：通过一个关联表和 secondary 参数实现。

SQLAlchemy 的 ORM（对象关系映射）模式通过将数据库表映射到 Python 类，并利用类之间的关系来构建数据库结构。以下是上述三种关系实现的原理：

1. 一对一关系（One-to-One）

一对一关系是最简单的关系，表示两个表之间一对一的关联。通常通过 ForeignKey 和 relationship 来实现。

原理：

1. 外键约束（ForeignKey）：

• 在一个表中定义一个外键（外键列），关联到另一个表的主键。
• 例如，在 Passport 表中定义 person_id 作为外键，关联到 Person 表的主键 id。

  person_id = Column(Integer, ForeignKey('persons.id'))
  

2. 双向关系（relationship）：

• 在两个类之间使用 relationship 属性，通过 back_populates 参数实现双向引用。
• 例如，Person 类中的 passport 属性和 Passport 类中的 person 属性相互引用。

  person = relationship("Person", back_populates="passport")
  passport = relationship("Passport", uselist=False, back_populates="person")
  

• 参数 uselist=False 表示该关系是一对一而非一对多。

3. 数据库结构：

• 数据库中会生成两个表：persons 和 passports。
• passports 表中有一个外键列 person_id，指向 persons 表的 id。

结果：

通过这种结构，每个 Person 对象只能有一个 Passport 对象，反之亦然。

2. 一对多关系（One-to-Many）

一对多关系是数据库中最常见的关系，表示一个记录可以关联到多个其他记录。

原理：

1. 外键约束（ForeignKey）：

• 在“多”的一方定义一个外键，关联到“一”的一方的主键。
• 例如，在 Child 表中定义 parent_id 作为外键，关联到 Parent 表的主键 id。

  parent_id = Column(Integer, ForeignKey('parents.id'))
  

2. 双向关系（relationship）：

• 在“一”的一方使用 relationship 属性，指定 back_populates 参数。
• 在“多”的一方也使用 relationship 属性，通过外键关联到“一”的一方。

  # Parent类的一对多关系
  children = relationship("Child", back_populates="parent")
  # Child类的反向关系
  parent = relationship("Parent", back_populates="children")
  

3. 数据库结构：

• 数据库中会生成两个表：parents 和 children。
• children 表中有一个外键列 parent_id，指向 parents 表的 id。

结果：

通过这种结构，每个 Parent 对象可以关联多个 Child 对象，但每个 Child 对象只能关联一个 Parent 对象。

3. 多对多关系（Many-to-Many）

多对多关系表示多个记录可以同时关联到多个其他记录。这种关系通常通过一个关联表（中间表）来实现。

原理：

1. 关联表（Association Table）：

• 定义一个中间表，包含两个外键，分别关联到两个主表的主键。
• 例如，association_table 包含 left_id 和 right_id 两个外键，分别关联到 left 和 right 表的主键。

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

2. 双向关系（relationship）：

• 在两个主表中使用 relationship 属性，通过 secondary 参数指定关联表。
• 使用 back_populates 参数实现双向引用。

  # Left类的多对多关系
  rights = relationship("Right", secondary=association_table, back_populates="lefts")
  # Right类的反向关系
  lefts = relationship("Left", secondary=association_table, back_populates="rights")
  

3. 数据库结构：

• 数据库中会生成三个表：left、right 和 association。
• association 表中包含两个外键列，分别指向 left 和 right 表的主键。

结果：

通过这种结构，Left 对象和 Right 对象可以相互关联，并且一个 Left 对象可以关联多个 Right 对象，反之亦然。

总结

1. “One-to-One”：

• 通过外键和 relationship 实现一对一关系，uselist=False 确保关系为一对一。

2. “One-to-Many”：

• 通过外键和 relationship 实现一对多关系，“一”的一方包含一个列表，用于存储“多”的一方的多个对象。

3. “Many-to-Many”：

• 通过中间表和 relationship 的 secondary 参数实现多对多关系，中间表存储两个表之间的关联。