SQLAlchemy核心与ORM：一篇搞懂Python数据库编程 – wiki大全

作者： /

SQLAlchemy核心与ORM：一篇搞懂Python数据库编程

在Python的生态系统中，当谈到与关系型数据库的交互时，SQLAlchemy无疑是最强大、最流行和功能最丰富的库之一。它提供了一个完整的SQL工具包和对象关系映射器（ORM），让开发者可以用Pythonic的方式来操作数据库。然而，许多初学者常常对其两大核心组件——SQLAlchemy Core和SQLAlchemy ORM——感到困惑。

本文将深入探讨这两个组件，阐明它们的设计理念、使用场景以及优缺点，帮助你根据项目需求做出正确的选择。

什么是SQLAlchemy？

SQLAlchemy自称为“Python SQL Toolkit and Object Relational Mapper”。这个描述非常准确，它包含了两个既独立又可协同工作的部分：

  1. Core（核心）：一个功能齐全的SQL表达式语言，它提供了一套模式（Schema）和类型系统，以及一个数据库连接池。它允许你使用Python对象来构建SQL语句，但不会隐藏SQL本身。
  2. ORM（对象关系映射器）：一个建立在Core之上的可选组件，它将用户自定义的Python类映射到数据库表上，让开发者可以操作对象而不是编写SQL语句。

简单来说，Core是更接近SQL的抽象层，而ORM是更接近Python对象的抽象层。

Part 1: SQLAlchemy Core – SQL的Pythonic表达

SQLAlchemy Core的主要目标不是隐藏SQL，而是用Python的方式来组织和执行它。当你需要精确控制SQL查询、进行数据分析或执行复杂的批量操作时，Core是你的最佳选择。

1.1 核心理念

  • SQL表达式语言（SQL Expression Language）：使用Python函数和对象（如select(), insert(), table(), column()）来构建SQL查询。这些对象最终会被编译成特定数据库方言的SQL字符串。
  • 数据库无关性：你编写的Core代码可以无缝地在PostgreSQL, MySQL, SQLite, Oracle等多种数据库之间切换，SQLAlchemy会处理不同数据库之间的语法差异。
  • 连接池与事务管理：内置高效的连接池管理，自动处理数据库连接的获取与释放，并提供清晰的事务控制。

1.2 如何使用Core？

我们通过一个简单的例子来感受一下。

步骤1：安装和创建引擎

首先，确保你已经安装了SQLAlchemy。

bash
pip install sqlalchemy

然后，创建一个Engine，它是与数据库交互的入口。

“`python
from sqlalchemy import create_engine

使用内存中的SQLite数据库作为示例

engine = create_engine(“sqlite:///:memory:”)
“`

步骤2：定义表结构（Schema）

使用MetaData, Table, Column等对象来定义数据库表的结构。

“`python
from sqlalchemy import MetaData, Table, Column, Integer, String

metadata_obj = MetaData()

定义一个名为’users’的表

users_table = Table(
“users”,
metadata_obj,
Column(“id”, Integer, primary_key=True),
Column(“name”, String(50)),
Column(“fullname”, String(100)),
)
“`

步骤3：创建表

使用metadata_obj.create_all()将定义的表结构应用到数据库中。

python
metadata_obj.create_all(engine)

步骤4：执行CRUD操作

Core的魅力在于构建查询的方式。

“`python
from sqlalchemy import insert, select, update, delete

使用with语句可以自动管理连接和事务

with engine.connect() as conn:
# 1. 插入 (INSERT)
stmt = insert(users_table).values(name=”spongebob”, fullname=”Spongebob Squarepants”)
conn.execute(stmt)

# 批量插入
conn.execute(
    insert(users_table),
    [
        {"name": "sandy", "fullname": "Sandy Cheeks"},
        {"name": "patrick", "fullname": "Patrick Star"},
    ],
)
conn.commit()  # 提交事务

# 2. 查询 (SELECT)
stmt = select(users_table).where(users_table.c.name == "sandy")
result = conn.execute(stmt)
for row in result:
    print(f"Found user: id={row.id}, name={row.name}, fullname={row.fullname}")

# 3. 更新 (UPDATE)
stmt = (
    update(users_table)
    .where(users_table.c.name == "spongebob")
    .values(fullname="SpongeBob SquarePants (Updated)")
)
conn.execute(stmt)
conn.commit()

# 4. 删除 (DELETE)
stmt = delete(users_table).where(users_table.c.name == "patrick")
conn.execute(stmt)
conn.commit()

“`

1.3 Core的优缺点

优点:
* 精确控制: 你可以构建任何复杂的SQL查询，性能几乎等同于原生SQL。
* 清晰直观: 对于熟悉SQL的开发者来说，Core的查询构建方式非常直观。
* 易于调试: 生成的SQL语句很容易打印和调试。
* 性能: 通常比ORM更快，因为它没有对象映射和会话管理的开销。

缺点:
* 代码冗长: 相对于ORM，需要编写更多的模板代码。
* 手动映射: 查询结果是基于行的元组（Row-like tuples），你需要手动将其转换为Python对象。

Part 2: SQLAlchemy ORM – 用对象操作数据库

SQLAlchemy ORM是构建在Core之上的高级抽象。它的核心思想是将数据库表映射到Python类，将表中的行映射为类的实例。这使得开发者可以完全用面向对象的方式来思考和编程，而将SQL的复杂性隐藏在幕后。

2.1 核心理念

  • 万物皆对象: 你操作的是Python对象，而不是SQL语句。session.add(my_object)取代了INSERT语句。
  • 工作单元模式（Unit of Work）: ORM通过一个名为Session的对象来跟踪所有变更。当你调用session.commit()时，它会自动将所有挂起的对象变更（增、删、改）智能地、高效地转换成SQL语句并一次性提交。
  • 关系管理: 轻松定义和管理类之间的一对一、一对多、多对多关系。

2.2 如何使用ORM？

我们用ORM重写上面的例子。

步骤1：设置（Engine已在Core部分创建）

ORM需要一个Session来管理与数据库的交互。

“`python
from sqlalchemy.orm import sessionmaker, declarative_base

创建一个Session类

Session = sessionmaker(bind=engine)

创建一个基类，我们自定义的ORM模型将继承它

Base = declarative_base()
“`

步骤2：定义映射类（Model）

创建一个继承自Base的Python类。

“`python
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import Mapped, mapped_column

class User(Base):
tablename = “users_orm” # 推荐使用与Core示例不同的表名以避免冲突

id: Mapped[int] = mapped_column(primary_key=True)
name: Mapped[str] = mapped_column(String(50))
fullname: Mapped[str]

def __repr__(self):
    return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

``
*注意：这里使用了SQLAlchemy 2.0风格的Mapped和mapped_column`，这是现代且推荐的方式。*

步骤3：创建表

“`python

将ORM模型对应的表创建到数据库中

Base.metadata.create_all(engine)
“`

步骤4：使用Session进行CRUD

所有操作都通过Session对象完成。

“`python
from sqlalchemy import select

创建一个session实例

with Session() as session:
# 1. 创建 (Create)
spongebob = User(name=”spongebob”, fullname=”Spongebob Squarepants”)
sandy = User(name=”sandy”, fullname=”Sandy Cheeks”)
patrick = User(name=”patrick”, fullname=”Patrick Star”)

session.add(spongebob)  # 添加单个对象
session.add_all([sandy, patrick])  # 添加多个对象

session.commit()  # 提交事务，此时INSERT语句才真正执行

# 2. 读取 (Read)
# 使用现代的select语法
stmt = select(User).where(User.name == "sandy")
sandy_user = session.scalars(stmt).first()
print(f"Found user: {sandy_user}")

# 3. 更新 (Update)
# 首先查询到对象
spongebob_user = session.get(User, spongebob.id) 
if spongebob_user:
    spongebob_user.fullname = "SpongeBob SquarePants (ORM Updated)"

session.commit() # 再次提交，ORM会自动检测到变更并生成UPDATE语句

# 4. 删除 (Delete)
patrick_user = session.get(User, patrick.id)
if patrick_user:
    session.delete(patrick_user)

session.commit() # 提交后，执行DELETE语句

“`

2.3 ORM的优缺点

优点:
* 开发效率高: 极大地减少了数据持久化层的代码量，让开发者专注于业务逻辑。
* 代码更Pythonic: 以面向对象的方式工作，更符合Python开发者的思维习惯。
* 自动管理: 自动处理对象状态、事务和关系加载。
* 减少错误: 编译器和类型提示可以捕获更多错误，而不是等到运行时才发现SQL语法错误。

缺点:
* 性能开销: ORM在对象跟踪、会话管理和SQL生成方面有一定的性能开销。
* 学习曲线: 高级特性（如懒加载、缓存、复杂关系）需要一定的学习成本。
* 失控风险: 对于复杂的查询，ORM生成的SQL可能不是最优的，有时难以预测其行为。

Core vs. ORM: 如何选择？

这是一个经典问题，答案是：“视情况而定，但两者可以并存！”

特性 SQLAlchemy Core SQLAlchemy ORM
抽象级别 低，接近SQL 高，接近业务对象
主要目标 编写可移植、可重用的SQL 将对象持久化到数据库
适合场景 数据分析、报表、ETL、需要手写优化SQL的性能敏感操作 Web应用、API后端、大多数CRUD密集型应用
思维模式 “我如何构建这个SQL查询？” “我如何操作这个User对象？”

选择指南：

  1. 对于应用开发者（如Web后端）: 默认使用ORM。ORM能极大地提升开发速度和代码可维护性。对于绝大多数标准的业务逻辑和CRUD操作，ORM是完美的选择。

  2. 对于数据工程师或分析师: 优先考虑Core。当你的主要任务是数据迁移、转换、生成复杂报表时，Core提供了必要的控制和性能。

  3. 混合使用（The Hybrid Approach）: 这是SQLAlchemy最强大的地方！你可以在一个使用ORM的应用中，随时“下降”到Core层面来执行特定的、复杂的查询。

混合使用示例：
在ORM应用中，假设你需要一个非常高效的批量更新操作，不希望有加载对象到内存的开銷。

“`python
with Session() as session:
# 这是一个Core风格的更新语句
stmt = (
update(User)
.where(User.name.like(“s%”))
.values(fullname=”[BATCH UPDATE] ” + User.fullname)
)

# 在ORM的session中执行Core语句
session.execute(stmt)
session.commit()

“`
这样，你既享受了ORM在日常开发中的便利，又能在关键时刻利用Core的强大性能和控制力。

结论

SQLAlchemy通过提供Core和ORM两个层面，满足了从底层SQL控制到高层对象抽象的全部需求。

  • SQLAlchemy Core 是一个强大的SQL工具包，适合需要精确控制SQL和追求极致性能的场景。
  • SQLAlchemy ORM 是一个高效的对象关系映射器，适合快速开发和构建业务逻辑复杂的应用程序。

理解它们各自的定位，并学会在合适的场景下混合使用它们，是精通Python数据库编程的关键。希望这篇文章能为你揭开SQLAlchemy的神秘面纱，让你在未来的项目中更加得心应手。

滚动至顶部