SQLAlchemy 是什么？一篇入门介绍 – wiki基地

作者： /

揭秘 SQLAlchemy：Python 数据库操作的瑞士军刀——一篇深度入门指南

在现代软件开发中，数据是核心。无论是网站的用户信息、电商平台的商品目录，还是复杂的业务交易记录，数据都存储在数据库里。作为 Python 开发者，我们如何高效、优雅、安全地与数据库进行交互呢？直接编写原生的 SQL 语句固然可行，但面对日益复杂的应用逻辑和多样的数据库系统，这种方式很快会变得繁琐、难以维护，并且容易出错。

这时，SQLAlchemy 应运而生。它不仅仅是一个简单的数据库连接库，更是一个功能强大、设计灵活的数据库工具包和对象关系映射器（Object-Relational Mapper, ORM）。对于 Python 开发者而言，SQLAlchemy 就像一把“瑞士军刀”，提供了多种与数据库交互的方式，能够适应从简单的脚本到大型企业级应用等各种场景的需求。

本文将带你深入了解 SQLAlchemy 是什么，它解决了哪些问题，以及如何开始使用它。我们将从 SQLAlchemy 的核心概念讲起，逐步探索它的两大主要组成部分：SQLAlchemy Core 和 SQLAlchemy ORM，并通过实际代码示例来展示它们的用法。

1. 为什么我们需要 SQLAlchemy？数据库交互的挑战

在深入 SQLAlchemy 之前，我们先来思考一下，直接使用 Python 数据库驱动（例如 psycopg2 for PostgreSQL, mysql-connector-python for MySQL, sqlite3 for SQLite）来操作数据库会遇到哪些问题：

  1. SQL 语句与代码逻辑耦合： 你需要在 Python 代码中嵌入大量的 SQL 字符串。当数据库模式（schema）发生变化时，你可能需要在代码库中搜索和修改大量的 SQL 语句。
  2. 数据类型转换： 数据库中的数据类型（如 INT, VARCHAR, DATE）需要手动转换为 Python 数据类型（如 int, str, datetime），反之亦然。这可能涉及重复的代码和潜在的错误。
  3. 对象与关系的不匹配（Impedance Mismatch）： Python 是面向对象的语言，我们习惯于使用对象来表示现实世界的实体（如一个 User 对象）。而关系型数据库将数据存储在表格中，以行和列的形式组织。将对象的状态存储到关系表中，以及从关系表中重建对象，是一个复杂且重复的工作。例如，一个 User 对象可能有一个包含多个 Address 对象的列表，这在关系型数据库中需要通过关联表来实现，手动处理这种一对多或多对多关系的代码非常繁琐。
  4. 数据库移植性差： 不同数据库系统的 SQL 语法、函数、特性可能有所不同。如果你想更换数据库后端（例如从 SQLite 迁移到 PostgreSQL），可能需要重写大量的 SQL 代码。
  5. 手动资源管理： 你需要手动管理数据库连接的打开和关闭，处理事务的提交和回滚，这容易遗漏或出错，导致资源泄露或数据不一致。
  6. 安全性： 手动拼接 SQL 字符串很容易遭受 SQL 注入攻击。虽然可以使用参数化查询来缓解，但这需要开发者时刻注意。

SQLAlchemy 的目标就是解决这些问题，提供一个更高层级的抽象，让开发者能够更专注于业务逻辑，而不是底层的数据库操作细节。

2. SQLAlchemy 是什么？核心定义

SQLAlchemy 是一个开源的 Python 库，它提供了灵活且强大的方式来与各种数据库进行交互。从根本上说，SQLAlchemy 可以被理解为以下两部分：

  • SQLAlchemy Core: 这是一个数据库抽象层和 SQL 表达式语言。它允许你用 Python 代码来构建 SQL 语句，而不是使用字符串。Core 提供了一套统一的接口来描述数据库模式（如表、列、索引）和生成针对不同数据库方言的 SQL 语句。你可以把它看作是一个更智能、更安全的 SQL 构建器和数据库连接管理器。
  • SQLAlchemy ORM: 这是一个建立在 SQLAlchemy Core 之上的对象关系映射器。ORM 允许你将 Python 类映射到数据库表，将 Python 对象映射到数据库行。通过 ORM，你可以像操作普通的 Python 对象一样来操作数据库中的数据，而无需直接编写 SQL。ORM 负责将对象操作转换为 SQL 语句，并将查询结果转换为 Python 对象。

理解 Core 和 ORM 的区别非常重要。Core 更接近于原始 SQL，提供高度的灵活性和控制力；而 ORM 提供了更高级的抽象，让你用面向对象的方式思考数据，牺牲了一定的底层控制力，但大大提高了开发效率，特别是在处理复杂的对象关系时。你可以根据项目的需求选择使用 Core、ORM，或者将它们结合起来使用。

3. 为什么选择 SQLAlchemy？它的优势

SQLAlchemy 之所以广受欢迎，得益于它的众多优势：

  • 灵活性和可配置性： SQLAlchemy 设计得非常灵活，你可以选择只使用 Core 部分来构建 SQL 表达式，或者使用 ORM 进行全面的对象映射。ORM 本身也有多种使用风格（如 Declarative 和 Classic Mapping）。几乎所有的行为都可以通过配置进行调整。
  • 强大的 ORM 功能： SQLAlchemy 的 ORM 功能强大且成熟，支持各种复杂的关系映射（一对一、一对多、多对多），提供了灵活的查询 API，支持惰性加载（Lazy Loading）和饥饿加载（Eager Loading）等优化手段。
  • 数据库无关性： SQLAlchemy 通过方言（Dialect）系统支持多种数据库后端（如 PostgreSQL, MySQL, SQLite, Oracle, SQL Server 等）。大多数情况下，你无需修改代码即可切换数据库，SQLAlchemy 会为你生成正确的 SQL 语法。
  • 高效的 SQL 表达式语言： SQLAlchemy Core 的 SQL 表达式语言允许你用 Python 代码构建 SQL 语句，这比手动拼接字符串更安全、更灵活。它还能在执行前进行优化。
  • 连接池和事务管理： SQLAlchemy 内置了健壮的连接池和事务管理机制，帮助你高效、可靠地管理数据库资源。
  • 安全性： SQLAlchemy Core 和 ORM 都使用参数绑定来执行 SQL 语句，这能够有效地防止 SQL 注入攻击。
  • 活跃的社区和详细的文档： SQLAlchemy 拥有一个活跃的社区，并且提供了非常详细、高质量的官方文档，遇到问题时很容易找到帮助。
  • 生产级就绪： SQLAlchemy 已经被广泛应用于各种规模的生产系统中，稳定性和性能都得到了验证。许多流行的 Python Web 框架（如 Flask, Pyramid）都有基于 SQLAlchemy 的扩展或默认推荐使用它。

4. SQLAlchemy Core 入门：像写 Python 一样写 SQL

SQLAlchemy Core 是 SQLAlchemy 的基础，它提供了一种使用 Python 代码构建 SQL 表达式的方式，同时管理数据库连接和执行。即使你主要使用 ORM，了解 Core 也是非常有益的，因为它能帮助你理解底层的工作原理，并在需要精细控制 SQL 时派上用场。

Core 的核心概念包括：

  • Engine: 数据库连接的入口。负责管理连接池和方言。
  • MetaData: 一个容器对象，用于存储数据库模式的信息，例如表的定义。
  • Table, Column: 用于在 Python 中描述数据库的表和列。
  • SQL Expressions: 用于构建 SELECT, INSERT, UPDATE, DELETE 等 SQL 语句的 Python 对象。
  • Connection: 代表一个到数据库的实际连接，用于执行 SQL 表达式。

让我们通过一个简单的例子来展示 Core 的用法：连接到 SQLite 数据库，创建一个表，插入一些数据，然后查询数据。

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

1. 创建 Engine

SQLite 数据库使用文件路径作为连接字符串

in-memory 数据库使用 sqlite:///:memory:

engine = create_engine(‘sqlite:///:memory:’)

2. 定义 MetaData 和 Table

MetaData 对象用于收集数据库模式的定义

metadata = MetaData()

定义一个名为 ‘users’ 的表

Table(‘表名’, MetaData对象, 列定义…)

users_table = Table(
‘users’,
metadata,
Column(‘id’, Integer, primary_key=True), # primary_key=True 表示这是主键
Column(‘name’, String),
Column(‘fullname’, String),
)

3. 创建表

调用 metadata.create_all(engine) 会检查数据库中是否存在这些表

如果不存在，则创建它们

metadata.create_all(engine)
print(“Table ‘users’ created successfully.”)

4. 插入数据

使用 engine.connect() 获取一个数据库连接

with engine.connect() as connection:
# 构建 INSERT 表达式
insert_statement = users_table.insert().values(name=’spongebob’, fullname=’Spongebob Squarepants’)

# 执行 INSERT 表达式
result = connection.execute(insert_statement)

# 对于有自增主键的表，inserted_primary_key 会返回新插入行的主键
print(f"Inserted user with ID: {result.inserted_primary_key}")

# 插入多行数据
more_users = [
    {'name': 'patrick', 'fullname': 'Patrick Star'},
    {'name': 'sandy', 'fullname': 'Sandy Cheeks'},
]
connection.execute(users_table.insert(), more_users) # execute() 可以接收一个列表进行批量插入

# 提交事务 (在 with engine.connect() as connection: 块中，连接对象会自动管理事务，
# 如果一切正常会在块结束时自动提交；如果发生异常则自动回滚。
# 在旧版本或特定场景下，你可能需要手动调用 connection.commit() 和 connection.rollback())
# connection.commit() # 在 with 块中通常不需要手动调用

print("More users inserted.")

5. 查询数据

with engine.connect() as connection:
# 构建 SELECT 表达式
# users_table.select() 等价于 SELECT * FROM users
select_statement = users_table.select()

# 执行 SELECT 表达式并获取结果集
result_set = connection.execute(select_statement)

print("\nQuerying all users:")
# 遍历结果集
for row in result_set:
    print(row) # 每一行是一个 RowProxy 对象，可以像元组或字典一样访问

# 查询特定条件的行
# 使用 users_table.c.name 引用列对象，然后使用比较运算符进行过滤
select_spongebob = users_table.select().where(users_table.c.name == 'spongebob')
spongebob_row = connection.execute(select_spongebob).fetchone() # fetchone() 获取第一行结果
print(f"\nQuerying user spongebob: {spongebob_row}")

# 更多查询示例：按条件过滤和排序
select_sorted = users_table.select().where(users_table.c.id > 1).order_by(users_table.c.name)
print("\nQuerying users with ID > 1, sorted by name:")
for row in connection.execute(select_sorted):
    print(row)

6. 更新数据

with engine.connect() as connection:
# 构建 UPDATE 表达式
update_statement = users_table.update().where(users_table.c.name == ‘patrick’).values(fullname=’Patrick STAR’)
connection.execute(update_statement)
# connection.commit() # 自动提交

print("\nUpdated Patrick's fullname.")

# 验证更新
print("\nQuerying updated Patrick:")
patrick_row = connection.execute(users_table.select().where(users_table.c.name == 'patrick')).fetchone()
print(patrick_row)

7. 删除数据

with engine.connect() as connection:
# 构建 DELETE 表达式
delete_statement = users_table.delete().where(users_table.c.name == ‘sandy’)
connection.execute(delete_statement)
# connection.commit() # 自动提交

print("\nDeleted Sandy.")

# 验证删除
print("\nQuerying all users after deletion:")
for row in connection.execute(users_table.select()):
    print(row)

Core 提供了对 SQL 的精细控制能力，适用于构建复杂的查询、存储过程调用、DDL 操作等场景，

或者当你需要极致性能而不想引入 ORM 的额外开销时。

“`

通过上面的例子，你可以看到 SQLAlchemy Core 如何使用 Python 对象来表示表、列和 SQL 操作。它将你从手动拼接 SQL 字符串的繁重工作中解放出来，并提供了更安全、更结构化的方式来与数据库交互。

5. SQLAlchemy ORM 入门：用对象拥抱数据库

SQLAlchemy ORM 是在 Core 之上构建的，它提供了一种更高级的抽象：将数据库表映射到 Python 类，将数据库行映射到 Python 对象。ORM 的核心理念是让你用面向对象的方式来思考和操作数据，而不是关系型的方式。

ORM 的核心概念包括：

  • Declarative Base: 用于声明式地定义数据库模型（Python 类与表的映射关系）。
  • Mapped Class: 一个 Python 类，通过 Declarative 或 Classic Mapping 方式与数据库表关联。类的属性通常映射到表的列。
  • Mapper: SQLAlchemy 在内部使用的机制，负责将 Python 类属性与表列进行映射。
  • Session: ORM 的核心工作单元。它提供了一个接口来加载、创建、删除对象，并将这些操作持久化到数据库中。Session 管理着对象的生命周期和数据库事务。你可以把它想象成一个“工作空间”或“缓存”，你在其中对对象进行修改，然后一次性将这些修改“刷新”到数据库。
  • Query: Session 提供的一个接口，用于构建和执行查询，返回映射的对象实例。

我们来演示如何使用 ORM 来完成之前 Core 的例子：连接到 SQLite 数据库，定义模型，创建表，插入数据，查询数据。

“`python
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import declarative_base, sessionmaker, relationship

1. 创建 Engine (与 Core 相同)

engine = create_engine(‘sqlite:///:memory:’)

2. 定义 Declarative Base

declarative_base() 返回一个 Base 类，我们的模型类将继承自它

Base = declarative_base()

3. 定义 ORM 模型 (映射到数据库表)

每个模型类继承自 Base

类名通常是单数形式，对应表名的单数或复数形式 (SQLAlchemy 默认表名为类名的小写复数形式，但可以配置)

class User(Base):
tablename = ‘users’ # 明确指定对应的表名

id = Column(Integer, primary_key=True) # 对应表的列
name = Column(String)
fullname = Column(String)

# 定义一个 __repr__ 方法方便打印对象信息
def __repr__(self):
    return f"<User(id={self.id}, name='{self.name}', fullname='{self.fullname}')>"

添加一个 Address 模型，演示 ORM 的关系映射

class Address(Base):
tablename = ‘addresses’

id = Column(Integer, primary_key=True)
email_address = Column(String, nullable=False) # nullable=False 表示不允许为 NULL
user_id = Column(Integer, ForeignKey('users.id')) # ForeignKey 定义外键关系，指向 users 表的 id 列

# 定义与 User 模型的关系
# relationship() 函数用于在模型之间建立联系，而不是在数据库层面定义外键（ForeignKey 是数据库层面的）
# 'User' 表示关联的模型类
# back_populates='addresses' 创建反向引用，在 User 对象上可以通过 user.addresses 访问关联的 Address 对象列表
user = relationship("User", back_populates="addresses")

def __repr__(self):
    return f"<Address(id={self.id}, email='{self.email_address}', user_id={self.user_id})>"

在 User 模型中添加一个 addresses 属性来建立反向关系

User.addresses = relationship(“Address”, order_by=Address.id, back_populates=”user”)

4. 创建表

Base.metadata 包含了所有继承自 Base 的模型定义的表信息

Base.metadata.create_all(engine)
print(“Tables ‘users’ and ‘addresses’ created successfully.”)

5. 创建 Session

sessionmaker 是一个工厂，用于创建 Session 对象

bind=engine 将创建的 Session 绑定到指定的 engine

SessionLocal = sessionmaker(bind=engine)

创建一个 Session 实例

session = SessionLocal()

6. 插入数据 (创建对象并添加到 Session)

创建 User 对象

spongebob = User(name=’spongebob’, fullname=’Spongebob Squarepants’)
patrick = User(name=’patrick’, fullname=’Patrick Star’)
sandy = User(name=’sandy’, fullname=’Sandy Cheeks’)

将对象添加到 Session

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

创建 Address 对象并关联到 User

spongebob_address = Address(email_address=’[email protected]’, user=spongebob) # 通过 user 属性直接关联
patrick_address = Address(email_address=’[email protected]’, user_id=patrick.id) # 或者通过 user_id 属性 (不推荐，推荐用对象关联)

添加 Address 对象到 Session

session.add(spongebob_address)

session.add(patrick_address) # 如果 Patrick 还没提交，patrick.id 是 None，所以用 user_id 会有问题

更安全的方式是先提交 user，或者通过 user 对象关联

或者，更典型的 ORM 方式是直接通过 User 对象的关联属性添加 Address 对象：

spongebob.addresses.append(Address(email_address=’[email protected]’)) # 这样添加，Address 对象也会自动添加到 session

注意：此时对象只是在 session 中处于 “pending” 状态，还没有写入数据库。

SQLAlchemy 会在需要时（例如执行查询前或调用 commit 时）自动将它们 “flush” 到数据库。

提交事务 (将 Session 中的变更写入数据库)

session.commit()

print(“\nUsers and Addresses inserted and committed.”)

提交后，对象处于 “persistent” 状态，它们与数据库中的行是同步的。

此时 spongebob.id 和 patrick.id 都会有数据库分配的值。

print(f”Spongebob ID after commit: {spongebob.id}”)
print(f”Patrick ID after commit: {patrick.id}”)

7. 查询数据 (使用 Session.query)

print(“\nQuerying all users:”)

session.query(User) 返回一个 Query 对象，可以链式调用各种过滤、排序、连接方法

all_users = session.query(User).all() # .all() 执行查询并返回所有结果的列表
for user in all_users:
print(user)

print(“\nQuerying user spongebob by name:”)

.filter() 使用列对象和比较运算符

spongebob_user = session.query(User).filter(User.name == ‘spongebob’).first() # .first() 返回第一个结果或 None
print(spongebob_user)

print(“\nQuerying users with ID > 1, sorted by name:”)

.filter() 和 .order_by()

users_sorted = session.query(User).filter(User.id > 1).order_by(User.name).all()
for user in users_sorted:
print(user)

print(“\nQuerying Spongebob’s addresses:”)

通过 ORM 关系访问关联对象

if spongebob_user:
# 当访问 spongebob_user.addresses 时，SQLAlchemy 会自动执行一个 SELECT 查询来加载关联的 Address 对象（惰性加载）
print(f”Spongebob’s addresses: {spongebob_user.addresses}”)

8. 更新数据

print(“\nUpdating Patrick’s fullname:”)
patrick_user = session.query(User).filter_by(name=’patrick’).one() # .one() 返回一个结果，如果结果不是一个或多个，则抛出异常
patrick_user.fullname = ‘Patrick STAR’ # 直接修改对象属性

session.add(patrick_user) # 修改 persistent 状态的对象通常不需要再次 add

session.commit() # commit 时，SQLAlchemy 会检测到对象的变更并生成 UPDATE 语句

print(“Updated Patrick’s fullname. Querying again:”)
patrick_user_updated = session.query(User).filter_by(name=’patrick’).one()
print(patrick_user_updated)

9. 删除数据

print(“\nDeleting Sandy:”)
sandy_user = session.query(User).filter_by(name=’sandy’).one()
session.delete(sandy_user) # 将对象标记为删除
session.commit() # commit 时，SQLAlchemy 会生成 DELETE 语句

print(“Deleted Sandy. Querying all users after deletion:”)
all_users_after_delete = session.query(User).all()
for user in all_users_after_delete:
print(user)

10. 关闭 Session

在实际应用中，通常使用 try/finally 或 with 语句来确保 session 被关闭

session.close()
print(“\nSession closed.”)

ORM 极大地简化了对象和数据库之间的转换工作，特别是在处理复杂的关联关系时。

你主要与 Python 对象和方法打交道，SQLAlchemy 在后台为你处理 SQL 细节。

“`

这个 ORM 示例展示了如何定义模型、创建 Session、通过对象进行增删改查，以及如何利用 relationship 定义模型之间的关联并进行访问。ORM 使得数据库操作更“Pythonic”，代码更易读、易写、易维护。

6. Core vs. ORM：何时选择哪个？

理解 Core 和 ORM 的差异以及各自的适用场景是使用 SQLAlchemy 的关键：

SQLAlchemy Core 适用场景：

  • 需要构建复杂的、特有的 SQL 语句： 当 ORM 的查询 API 无法满足你的需求，或者构建复杂的 JOIN、子查询、窗口函数等在 ORM 中显得繁琐时，Core 的 SQL 表达式语言提供了更大的灵活性。
  • 执行批量操作： Core 通常在执行大量插入、更新或删除操作时性能更高，因为它避免了 ORM 对象的创建和管理开销。
  • 执行 DDL 操作： 虽然 ORM 可以通过 Base.metadata.create_all() 等方式执行 DDL，但 Core 提供了更细粒度的 DDL 控制。
  • 调用存储过程或数据库特定函数： Core 提供了执行任意 SQL 语句的能力。
  • 性能敏感的代码路径： 在对性能要求极致的场景下，使用 Core 可以避免 ORM 的一些开销（尽管 ORM 通常已经足够快，并且提供了多种优化手段）。
  • 作为 ORM 的补充： 你可以在 ORM 应用中，针对特定场景使用 Core 来执行操作，例如批量导入数据。

SQLAlchemy ORM 适用场景：

  • 典型的 CRUD（创建、读取、更新、删除）操作： 大多数业务逻辑涉及将对象持久化到数据库，以及从数据库加载对象进行操作。ORM 将这些操作简化为对 Python 对象的方法调用和属性访问。
  • 管理复杂的对象关系： ORM 的 relationship 功能使得处理一对一、一对多、多对多关系变得异常简单，你可以轻松地在关联对象之间导航。
  • 快速开发： ORM 减少了大量的重复性代码（如数据类型转换、SQL 编写），显著提高了开发效率。
  • 代码可读性和维护性： 使用 ORM，你的代码更多地是与业务领域的概念（对象）打交道，而不是数据库的细节，这使得代码更易于理解和维护。
  • 数据库移植性： ORM 的抽象层使得切换数据库后端更加容易。

总结：

对于大多数 Python 应用程序，ORM 是主要的数据库交互方式，因为它提供了更高的抽象级别和开发效率。然而，Core 并不是无关紧要的，它是 ORM 的基础，并在需要底层控制或处理特定复杂 SQL 场景时提供了必要的工具。许多大型项目会结合使用 ORM 和 Core，以充分利用两者的优势。

7. 关键概念深入

前面我们简要介绍了 Core 和 ORM 的核心概念。这里我们再稍微深入一些：

  • Engine: create_engine() 函数是 SQLAlchemy 的起点。它根据你提供的数据库 URL（连接字符串）和一些参数（如连接池大小、回显 SQL 语句等）来配置数据库连接。Engine 本身不代表一个连接，而是一个连接池的管理器。
  • MetaData: Core 和 ORM 都使用 MetaData 来描述数据库模式。在 ORM 中，Base.metadata 自动收集所有声明的模型定义。
  • Connection (Core): 从 Engine 获取的 Connection 对象代表一个实际的数据库会话。它用于执行 Core 的 SQL 表达式，并提供事务控制（通过 begin() 或 with engine.connect() as conn:）。
  • Session (ORM): Session 是 ORM 的主要接口。它是一个“工作单元”模式的实现。你在 Session 中对对象进行操作（创建、加载、修改、删除），这些操作会暂存在 Session 中，直到你调用 session.commit() 或 session.flush() 时才会被翻译成 SQL 并发送到数据库。Session 会跟踪对象的状态（pending, persistent, detached, deleted），并管理它们与数据库行的同步。一个良好的实践是为每个逻辑工作单元（如处理一个 Web 请求）创建一个新的 Session，并在工作完成后关闭它。
  • Mapping: 这是 ORM 的核心机制，将 Python 类映射到数据库表，类属性映射到表列。Declarative Mapping 是最常用的方式，它将类定义、表定义和映射信息结合在一个地方。
  • Relationships: ORM 的杀手级特性。relationship() 函数在模型之间建立关联，使得你可以通过对象的属性来访问相关的对象（例如，user.addresses）。SQLAlchemy 会在后台处理所需的 JOIN 或单独查询来加载关联数据。你可以配置关系的加载策略（如懒加载、急加载、子查询加载等）来优化性能。
  • Querying (ORM): session.query(Model) 返回一个 Query 对象，提供了丰富的链式方法来构建查询，如 filter(), filter_by(), join(), order_by(), group_by(), limit(), offset() 等。.all(), .first(), .one(), .count() 等方法用于执行查询并获取结果。ORM 查询返回的是模型对象列表或单个对象，而不是 Core 返回的 RowProxy 对象。

8. 环境搭建与入门步骤

要开始使用 SQLAlchemy，你需要以下几个步骤：

  1. 安装 SQLAlchemy: 使用 pip 安装：
    bash
    pip install SQLAlchemy
  2. 安装数据库驱动： SQLAlchemy 本身不包含数据库驱动，你需要根据你使用的数据库安装相应的 Python 库。例如：
    • PostgreSQL: pip install psycopg2
    • MySQL: pip install mysqlclient (或 mysql-connector-python)
    • SQLite: Python 标准库自带，无需额外安装
    • SQL Server: pip install pyodbc
  3. 编写连接字符串： 数据库连接字符串的格式通常是 dialect+driver://user:password@host:port/database。例如：
    • SQLite 文件数据库: sqlite:///path/to/database.db
    • PostgreSQL: postgresql://user:password@host:port/database
    • MySQL: mysql+mysqlconnector://user:password@host:port/database
  4. 创建 Engine: 在你的代码中使用 create_engine() 函数。
  5. 定义模型 (ORM) 或表 (Core): 使用 Declarative Base 或 MetaData, Table 定义你的数据库结构。
  6. 创建表： 使用 Base.metadata.create_all(engine) (ORM) 或 metadata.create_all(engine) (Core)。
  7. 创建 Session (ORM) 或 Connection (Core): 使用 sessionmaker 创建 Session 工厂并获取 Session 实例，或使用 engine.connect() 获取 Connection 实例。
  8. 执行操作： 使用 Session 或 Connection 进行增删改查。
  9. 提交/回滚事务： 使用 session.commit()/session.rollback() (ORM) 或 connection.commit()/connection.rollback() (Core)，或者依赖 with 语句的自动管理。
  10. 关闭 Session/Connection： 确保资源被释放。使用 with 语句是推荐的方式。

9. 更进一步的学习资源

本文为你提供了一个详细的 SQLAlchemy 入门介绍。SQLAlchemy 功能强大且深入，还有许多高级特性值得探索，例如：

  • 连接池配置和优化
  • 事务隔离级别
  • 各种关系加载策略（惰性加载、急加载、子查询加载、关联加载）
  • 复杂的 JOIN 和子查询
  • 事件系统（Events）
  • 使用 Alembic 进行数据库模式迁移
  • 自定义类型和方言
  • Core 的更多高级用法

要深入学习这些内容，强烈推荐查阅 SQLAlchemy 的官方文档。虽然文档内容丰富，可能初看有些复杂，但它是最权威和详细的学习资源。此外，还有许多优秀的博客文章、教程和书籍可以帮助你掌握 SQLAlchemy。

10. 总结

SQLAlchemy 是 Python 生态系统中最强大、最灵活的数据库工具包。它通过 SQLAlchemy Core 提供的 SQL 表达式语言，让你能够以更安全、更结构化的方式构建底层 SQL；而其成熟的 ORM 则允许你用面向对象的方式操作数据库，极大地提高了开发效率，尤其是在处理复杂的对象关系时。

理解 Core 和 ORM 各自的优势和适用场景，并学会在需要时结合使用它们，将使你成为一个更高效、更优秀的 Python 开发者。从本文开始，动手实践代码示例，逐步探索 SQLAlchemy 的更多特性，你将能够自信地处理各种数据库交互任务，构建健壮、可维护的应用程序。

希望这篇详细的入门指南能够帮助你迈出学习 SQLAlchemy 的第一步！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部