SQLAlchemy 快速入门
ORM 工具库
https://docs.sqlalchemy.org/en/20/index.html
ORM 快速入门
声明模型
Declare Models
我们定义模块级构造，这些构造将形成我们将从数据库查询的结构。
这种结构被称为声明式映射(Declarative Mapping)，它同时定义了Python对象模型，以及描述特定数据库中存在或将存在的真实SQL表的数据库元数据:
from typing import Optional, List
from sqlalchemy import ForeignKey, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
# mapped_column Mapped 为2.0 新的格式 Python类型和SQL类型之间的关联可以使用类型注释映射自定义。
# 映射从一个基类开始，上面称为base，并通过针对DeclarativeBase类创建一个简单的子类来创建。
空性取决于是否使用了Optional[]类型修饰符。
可以使用右侧mapped_column()指令中的SQLAlchemy类型对象来指示更具体的类型信息，例如上面在User.name列中使用的字符串数据类型。
class Base(DeclarativeBase):
__abstract__ = True
# 定义共有属性
# 每个列的数据类型首先取自与每个映射注释相关联的Python数据类型;
# int表示INTEGER, str表示VARCHAR，等等。
id: Mapped[int] = mapped_column(primary_key=True)
# 定义__repr__方法不是必要的
def __repr__(self) -> str:
return f"{self.__tablename__} (id={self.id!r}"
class User(Base):
__tablename__ = "user"
name: Mapped[str] = mapped_column(String(30))
fullname: Mapped[Optional[str]] # Optional 表示可为空
# relationship 表示两表之间的关系，方便关联查询。List 表示一对多 。非数据库约束。
addresses: Mapped[List["Address"]] = relationship(
back_populates="user", cascade="all, delete-orphan"
)
class Address(Base):
__tablename__ = "address"
email_address: Mapped[str]
user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
user: Mapped["User"] = relationship(back_populates="addresses")
# back_populates 表示反向关系，即关联表中可以通过 addresses 反向查找
类型补充
除了 str int 外 还有时间
from datetime import datetime
created_at: Mapped[datetime] = mapped_column(
insert_default=func.utc_timestamp(), default=None
)
另一种方法
在 SQLAlchemy 中，定义表有两种主要的方式：使用 Table 类和使用继承 declarative_base() 后的基类。
from sqlalchemy import MetaData, Table, Column, Integer, String
metadata = MetaData()
users = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
Column('age', Integer)
)
-----------------------
使用 Table 类：使用 Table 类可以直接定义表的结构，包括表的名称、列名、数据类型等信息。这种方式更加灵活，适用于在代码中动态地定义表结构，或者对现有的数据库进行操作。你可以通过 metadata.create_all() 方法来创建表，也可以使用 engine.execute() 方法直接执行 SQL 语句来创建表。
这两种方式各有优缺点，选择取决于你的具体需求和开发习惯。通常情况下，如果你习惯使用对象来表示数据库中的表，并且希望利用 SQLAlchemy 提供的 ORM（对象关系映射）功能来简化数据库操作，那么推荐使用继承 declarative_base() 后的基类。如果你需要更灵活地控制数据库结构，或者需要对现有数据库进行动态的、基于代码的操作，那么使用 Table 类可能更合适。
表关系
数据本身对表之间约束关系为外键 ForeignKey 这个会在数据库中作为实际字段体现 。ForeignKey 本身也是一个逻辑关系的体验 存在的为从表。一般关联到主表的主键
ORM 中可以只表示表的逻辑关系使用 relationship 这个是在数据中不会实际体现的。 逻辑关系分为 一对多 多对多 一对一 ，其中多对多是通过中间表来实现。
# 外键 约束 表示将user_account 的主键id 作为字段
mapped_column(ForeignKey("user_account.id"))
# 逻辑关系
addresses: Mapped[List["Address"]] = relationship(
back_populates="user", cascade="all, delete-orphan"
)
多对多关系
Base = declarative_base()
# 定义关联表
association_table = Table('association', Base.metadata,
Column('user_id', Integer, ForeignKey('users.id')),
Column('group_id', Integer, ForeignKey('groups.id'))
)
注意 多对多关系 使用 relationship 会有变化
groups = relationship("Group", secondary=association_table, back_populates="users")
创建引擎
Create an Engine
引擎 是一个工厂factory 用来创建数据连接。
from sqlalchemy import create_engine
engine = create_engine("sqlite://", echo=True) # echo=True 表示sql 记录会输出
连接其他数据库
# 连接 mysql pymysql 是需要的驱动库 需要下载
'mysql+pymysql://root:your_password@localhost:3306/your_database?charset=utf8mb4'
发出创建表DDL
Emit CREATE TABLE DDL
# 这个操作将在数据生成sql 并在数据库中创建 对应表
Base.metadata.create_all(engine) # 已经存在则不会创建
数据操作
新增数据
Create Objects and Persis 创建对象和持久化
实例化 表对象 并在数据库中添加数据
from .model import engine, User, Address
from sqlalchemy.orm import Session # 新建连接需要Session 确认更改需要commit
with Session(engine) as session:
spongebob = User(
name="spongebob",
fullname="Spongebob Squarepants",
addresses=[Address(email_address="spongebob@sqlalchemy.org")], # 自动创建关联对象
)
sandy = User(
name="sandy",
fullname="Sandy Cheeks",
addresses=[
Address(email_address="sandy@sqlalchemy.org"),
Address(email_address="sandy@squirrelpower.org"),
],
)
patrick = User(name="patrick", fullname="Patrick Star")
session.add_all([spongebob, sandy, patrick])
session.commit()
查询
Simple SELECT
通过orm 方式也可以代替sql 做查询操作
from sqlalchemy import select
session = Session(engine)
stmt = select(User).where(User.name.in_(["spongebob", "sandy"])) # 相当于生成了查询语句
for user in session.scalars(stmt): # 执行查询是 session.scalars(stmt)
print(user)
多表查询
SELECT with JOIN
stmt = (
select(Address)
.join(Address.user)
.where(User.name == "sandy")
.where(Address.email_address == "sandy@sqlalchemy.org")
)
sandy_address = session.scalars(stmt).one()
---------------------------------
SELECT address.id, address.email_address, address.user_id
FROM address JOIN user_account ON user_account.id = address.user_id
WHERE user_account.name = ? AND address.email_address = ?
[...] ('sandy', 'sandy@sqlalchemy.org')
改数据
先查再改
stmt = select(User).where(User.name == "patrick")
patrick = session.scalars(stmt).one()
patrick.addresses.append(Address(email_address="patrickstar@sqlalchemy.org"))
sandy_address.email_address = "sandy_cheeks@sqlalchemy.org"
session.commit()
删除
Some Deletes
sandy = session.get(User, 2)
sandy.addresses.remove(sandy_address) # 确认后删除
session.flush() # 提交 flush 相当于暂存提高 性能 减少 commit 减少资源消耗 这里使用flush 确认remove删除 否则不会删除
session.delete(patrick) # 立刻删除
session.commit()
