SQLAlchemy ORM教程：Python数据库访问神器

需积分: 3 169 浏览量更新于2024-06-23 收藏 12.96MB PDF 举报

SQLAlchemy教程是一个针对Python编程语言的开源框架，它旨在提供高效的数据库访问工具和对象关系映射（ORM）功能。这个框架强调SQL数据库的性能和规模，同时保持对象集合的抽象性，采用了类似Java Hibernate的数据映射模型而非Active Record模型。SQLAlchemy的核心组件包括Core和ORM，它们各自承担着不同的职责。 Core是SQLAlchemy的基础，它包含了广泛的SQL服务和数据库集成，特别是SQL表达式语言，这是一种独立于ORM的工具，允许开发者构造SQL表达式并根据上下文执行，支持DML操作（如INSERT、UPDATE、DELETE）。Core提供了一个模式中心的数据库视图，以及面向不变性的编程模式。 ORM则在Core之上，专注于以对象模型的方式处理数据库操作，通过领域对象与数据库模式进行映射。ORM简化了持久化操作，利用unitofwork机制自动管理对象状态的改变，将这些变化转换为相应的SQL语句。此外，ORM还提供了面向对象的查询功能，构建了一种以域为中心的数据库视图，强调对象的可变性和依赖性。教程分为四部分： 1. SQLAlchemy 1.4/2.0 教程 - 适用于新用户和希望从1.x版本过渡到2.0风格的开发者，覆盖整个库，从Core的介绍开始，逐步深入ORM概念。 2. SQLAlchemy ORM - 详细介绍ORM的参考文档，包括遗留的1.x API和对象关系教程。 3. SQLAlchemy Core - 提供Core内部的详细文档，涵盖了传统SQL表达式语言教程以及引擎、连接和池服务的使用。 4. 题材 - 针对所有用户的方言部分，讨论如何根据不同数据库系统调整和使用SQLAlchemy。学习SQLAlchemy不仅需要理解它的核心原理，还需要熟悉ORM的特性和使用方法，以便在实际项目中充分利用其优势。通过这个教程，开发者能够掌握如何有效地与Python代码交互，同时确保数据的高效管理和一致性。

SELECT语句：

>>> subq = select(func.count(address_table.c.id)).\

... where(user_table.c.id == address_table.c.user_id).\

... scalar_subquery()

>>> print(subq)

(SELECT count(address.id) AS count_1

FROM address, user_account

WHERE user_account.id = address.user_id)

以上内容 subq 对象现在落在 ColumnElement SQL表达式层次结构，因为它可以像任何其他列表达式一样使用：：

>>> print(subq == 5)

(SELECT count(address.id) AS count_1

FROM address, user_account

WHERE user_account.id = address.user_id) = :param_1

尽管标量子查询本身呈现了这两个 user_account 和 address 在其FROM子句中单独串行化时，将其嵌入到封闭的 select() 构造处理 user_account 表中的 user_account 表格会自动相关相关，这意味着它不会在子查询的FROM子

句中呈现：：

>>> stmt = select(user_table.c.name, subq.label("address_count"))

>>> print(stmt)

SELECT user_account.name, (SELECT count(address.id) AS count_1

FROM address

WHERE user_account.id = address.user_id) AS address_count

FROM user_account

简单的相关子查询通常会执行所需的正确操作。但是，在关联不明确的情况下，SQLAlChemy会让我们知道需要更加清晰：

>>> stmt = select(

... user_table.c.name,

... address_table.c.email_address,

... subq.label("address_count")

... ).\

... join_from(user_table, address_table).\

... order_by(user_table.c.id, address_table.c.id)

>>> print(stmt)

Traceback (most recent call last):

...

InvalidRequestError: Select statement '<... Select object at ...>' returned

no FROM clauses due to auto-correlation; specify correlate(<tables>) to

control correlation manually.

要指定 user_table 是我们寻求关联的对象，我们使用 ScalarSelect.correlate() 或 ScalarSelect.correlate_except() 方法：

>>> subq = select(func.count(address_table.c.id)).\

... where(user_table.c.id == address_table.c.user_id).\

... scalar_subquery().correlate(user_table)

然后，该语句可以像返回任何其他列一样返回该列的数据：

>>> with engine.connect() as conn:

... result = conn.execute(

... select(

... user_table.c.name,

... address_table.c.email_address,

... subq.label("address_count")

... ).

... join_from(user_table, address_table).

... order_by(user_table.c.id, address_table.c.id)

... )

... print(result.all())

BEGIN (implicit)

SELECT user_account.name, address.email_address, (SELECT count(address.id) AS count_1

FROM address

WHERE user_account.id = address.user_id) AS address_count

FROM user_account JOIN address ON user_account.id = address.user_id ORDER BY user_account.id, address.id

[...] ()

[('spongebob', 'spongebob@sqlalchemy.org', 1), ('sandy', 'sandy@sqlalchemy.org', 2),

('sandy', 'sandy@squirrelpower.org', 2)]

ROLLBACK

UNION、UNION ALL和其他集合运算

在SQL中，可以使用UNION或UNION ALL SQL操作将SELECT语句合并在一起，这将生成一条或多条语句一起生成的所有行的集合。其他集合操作，如交集 [ALL] 而且除了 [ALL] 也是可能的。

SQLAlChemy的 Select Construct使用如下函数支持这种性质的组合 union() ， intersect() 和 except_() ，以及“所有”对应项 union_all() ， intersect_all() 和 except_all() 。这些函数都接受任意数量的子选择，它们

通常是 Select 构造，但也可以是现有的合成。

由这些函数生成的构造是 CompoundSelect ，它的使用方式与 Select 构造，只是它的方法较少。这个 CompoundSelect 制作人 union_all() 例如，可以使用以下命令直接调用 Connection.execute() ：：

>>> from sqlalchemy import union_all

>>> stmt1 = select(user_table).where(user_table.c.name == 'sandy')

>>> stmt2 = select(user_table).where(user_table.c.name == 'spongebob')

>>> u = union_all(stmt1, stmt2)

>>> with engine.connect() as conn:

... result = conn.execute(u)

... print(result.all())

BEGIN (implicit)

SELECT user_account.id, user_account.name, user_account.fullname

FROM user_account

WHERE user_account.name = ?

UNION ALL SELECT user_account.id, user_account.name, user_account.fullname

FROM user_account

WHERE user_account.name = ?

[generated in ...] ('sandy', 'spongebob')

[(2, 'sandy', 'Sandy Cheeks'), (1, 'spongebob', 'Spongebob Squarepants')]

ROLLBACK

要使用 CompoundSelect 作为子查询，就像 Select 它提供了一个 SelectBase.subquery() 方法，该方法将产生 Subquery 对象，并使用 FromClause.c 集合，该集合可以在随附的 select() ：：

>>> u_subq = u.subquery()

>>> stmt = (

... select(u_subq.c.name, address_table.c.email_address).

... join_from(address_table, u_subq).

... order_by(u_subq.c.name, address_table.c.email_address)

... )

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT anon_1.name, address.email_address

FROM address JOIN

(SELECT user_account.id AS id, user_account.name AS name, user_account.fullname AS fullname

FROM user_account

WHERE user_account.name = ?

UNION ALL

SELECT user_account.id AS id, user_account.name AS name, user_account.fullname AS fullname

FROM user_account

WHERE user_account.name = ?)

AS anon_1 ON anon_1.id = address.user_id

ORDER BY anon_1.name, address.email_address

[generated in ...] ('sandy', 'spongebob')

[('sandy', 'sandy@sqlalchemy.org'), ('sandy', 'sandy@squirrelpower.org'), ('spongebob', 'spongebob@sqlalchemy.org')]

ROLLBACK

存在的子查询

SQL EXISTS关键字是与一起使用的运算符 scalar subqueries 返回布尔值TRUE或FALSE，具体取决于SELECT语句是否返回一行。SQLAlChemy包括 ScalarSelect 调用的对象 Exists ，它将生成Existes子查询，最方便的生成方式

是使用 SelectBase.exists() 方法。下面我们生成一个存在，这样我们就可以返回 user_account 中有多个相关行的行 address ：

>>> subq = (

... select(func.count(address_table.c.id)).

... where(user_table.c.id == address_table.c.user_id).

... group_by(address_table.c.user_id).

... having(func.count(address_table.c.id) > 1)

... ).exists()

>>> with engine.connect() as conn:

... result = conn.execute(

... select(user_table.c.name).where(subq)

... )

... print(result.all())

BEGIN (implicit)

SELECT user_account.name

FROM user_account

WHERE EXISTS (SELECT count(address.id) AS count_1

FROM address

WHERE user_account.id = address.user_id GROUP BY address.user_id

HAVING count(address.id) > ?)

[...] (1,)

[('sandy',)]

ROLLBACK

EXISTS结构通常用作否定，例如NOT EXISTS，因为它提供了一种SQL高效的形式来定位相关表没有行的行。下面我们选择没有电子邮件地址的用户名；请注意二元否定运算符 ( ~ )在第二个WHERE子句中使用：

>>> subq = (

... select(address_table.c.id).

... where(user_table.c.id == address_table.c.user_id)

... ).exists()

>>> with engine.connect() as conn:

... result = conn.execute(

... select(user_table.c.name).where(~subq)

... )

... print(result.all())

BEGIN (implicit)

SELECT user_account.name

FROM user_account

WHERE NOT (EXISTS (SELECT address.id

FROM address

WHERE user_account.id = address.user_id))

[...] ()

[('patrick',)]

ROLLBACK

使用SQL函数

在本节的前面部分中首次介绍，位置是使用GROUP BY/HAVING聚合函数，即 func 对象用作创建新的 Function 对象，当在类似的构造中使用这些对象时， select() 生成一个SQL函数显示，通常由名称、一些括号(尽管不总是)

和可能的一些参数组成。典型的SQL函数示例包括：

这个 count() 函数，一个计算返回行数的聚合函数：

>>> print(select(func.count()).select_from(user_table))

SELECT count(*) AS count_1

FROM user_account

这个 lower() 函数，将字符串转换为小写的字符串函数：

>>> print(select(func.lower("A String With Much UPPERCASE")))

SELECT lower(:lower_2) AS lower_1

这个 now() 函数，该函数提供当前日期和时间；由于这是一个常见的函数，因此SQLAlChemy知道如何为每个后端以不同的方式呈现它，在SQLite中使用CURRENT_TIMESTAMP函数：

>>> stmt = select(func.now())

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT CURRENT_TIMESTAMP AS now_1

[...] ()

[(datetime.datetime(...),)]

ROLLBACK

由于大多数数据库后端具有数十个(如果不是数百个)不同的SQL函数， func 在接受的问题上尽量做到自由。从此命名空间访问的任何名称都自动被视为将以通用方式呈现的SQL函数：：

>>> print(select(func.some_crazy_function(user_table.c.name, 17)))

SELECT some_crazy_function(user_account.name, :some_crazy_function_2) AS some_crazy_function_1

FROM user_account

同时，相对较小的一组极其常见的SQL函数，例如 count ， now ， max ， concat 包括它们自身预打包版本，它们在某些情况下提供正确的键入信息以及特定于后端的SQL生成。下面的示例将PostgreSQL方言的SQL生成与

Oracle方言的SQL生成进行了对比 now 功能：：

>>> from sqlalchemy.dialects import postgresql

>>> print(select(func.now()).compile(dialect=postgresql.dialect()))

SELECT now() AS now_1

>>> from sqlalchemy.dialects import oracle

>>> print(select(func.now()).compile(dialect=oracle.dialect()))

SELECT CURRENT_TIMESTAMP AS now_1 FROM DUAL

函数具有返回类型

因为函数是列表达式，所以它们也有SQL datatypes 描述生成的SQL表达式的数据类型的。我们在这里将这些类型称为“SQL返回类型”，指的是数据库端SQL表达式上下文中函数返回的SQL值的类型，而不是Python函数的“返回类

型”。

通常出于调试目的，可以访问任何SQL函数的SQL返回类型，方法是引用 Function.type 属性：：

>>> func.now().type

DateTime()

在较大表达式的上下文中使用函数表达式时，这些SQL返回类型非常重要；也就是说，当表达式的数据类型类似于以下内容时，数学运算符的工作效果会更好 Integer 或 Numeric ，JSON访问器为了正常工作需要使用如下类型

JSON 。某些函数类返回整行而不是列值，在这种情况下需要引用特定的列；此类函数称为 table valued functions 。

对于SQLAlChemy必须应用结果集处理的情况，在执行语句和取回行时，函数的SQL返回类型可能也很重要。SQLite上与日期相关的函数就是一个很好的例子，SQLAlChemy的 DateTime 并且相关的数据类型承担着从字符串值转换到

Python的角色 datetime() 对象作为结果行被接收。

要将特定类型应用于我们正在创建的函数，我们使用 Function.type_ 参数；类型参数可以是 TypeEngine 类或实例。在下面的示例中，我们将 JSON 类来生成PostgreSQL json_object() 函数，请注意SQL返回类型将是JSON：：

>>> from sqlalchemy import JSON

>>> function_expr = func.json_object('{a, 1, b, "def", c, 3.5}', type_=JSON)

通过使用 JSON DataType中，SQL表达式对象具有与JSON相关的功能，例如访问元素：

>>> stmt = select(function_expr["def"])

>>> print(stmt)

SELECT json_object(:json_object_1)[:json_object_2] AS anon_1

内置函数具有预配置的返回类型

对于常见的聚合函数，如 count ， max ， min 以及非常少量的日期函数(如 now 和字符串函数，如 concat ，则适当设置SQL返回类型，有时会根据使用情况进行设置。这个 max 函数和类似的聚合过滤函数将根据给定的参数设

置SQL返回类型：：

>>> m1 = func.max(Column("some_int", Integer))

>>> m1.type

Integer()

>>> m2 = func.max(Column("some_str", String))

>>> m2.type

String()

日期和时间函数通常对应于 DateTime ， Date 或 Time ：：

>>> func.now().type

DateTime()

>>> func.current_date().type

Date()

已知的字符串函数，例如 concat 将知道SQL表达式的类型为 String ：：

>>> func.concat("x", "y").type

String()

但是，对于绝大多数SQL函数，SQLAlChemy没有将它们显式地显示在其非常小的已知函数列表中。例如，虽然使用SQL函数通常没有问题 func.lower() 和 func.upper() 为了转换字符串的大小写，SQLAlChemy实际上并不知道这

些函数，因此它们具有“null”SQL返回类型：

>>> func.upper("lowercase").type

NullType()

对于简单的函数，如 upper 和 lower 问题通常不大，因为从数据库接收字符串值时不需要在SQLAlChemy端进行任何特殊类型处理，而且SQLAlChemy的类型强制规则通常也可以正确猜测意图；Python + 例如，根据查看表达式的

两侧，运算符将被正确解释为字符串连接运算符：：

>>> print(select(func.upper("lowercase") + " suffix"))

SELECT upper(:upper_1) || :upper_2 AS anon_1

总体而言， Function.type_ 可能需要的参数是：

1. 该函数还不是SQLAlChemy内置函数；这可以通过创建该函数并观察 Function.type 属性，即：：

>>> func.count().type

Integer()

对比：：

>>> func.json_object('{"a", "b"}').type

NullType()

2. 需要函数感知表达式支持；这通常是指与数据类型相关的特殊运算符，例如 JSON 或 ARRAY

3. 需要对结果值进行处理，这可能包括以下类型 DateTime ， Boolean ， Enum ，或者同样是特殊的数据类型，如 JSON ， ARRAY 。

使用窗口函数

窗口函数是SQL聚合函数的特殊用法，它在处理单个结果行时计算组中返回的行的聚合值。而像这样的函数 MAX() 将为您提供一组行中某列的最高值，使用与“窗口函数”相同的函数将为您提供每行的最高值，

从那一行开始

。

在SQL中，窗口函数允许指定应该对其应用函数的行、考虑不同行子集上的窗口的“分区”值，以及重要地指示应将行应用于聚合函数的顺序的“order by”表达式。

在SQLAlChemy中，由 func 命名空间包括一个方法 FunctionElement.over() 它授予窗口函数或“over”语法；生成的构造是 Over 构造。

与窗口函数一起使用的一个常见函数是 row_number() 函数，该函数简单地计算行数。我们可以根据用户名对此行计数进行分区，以对各个用户的电子邮件地址进行编号：

>>> stmt = select(

... func.row_number().over(partition_by=user_table.c.name),

... user_table.c.name,

... address_table.c.email_address

... ).select_from(user_table).join(address_table)

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT row_number() OVER (PARTITION BY user_account.name) AS anon_1,

user_account.name, address.email_address

FROM user_account JOIN address ON user_account.id = address.user_id

[...] ()

[(1, 'sandy', 'sandy@sqlalchemy.org'), (2, 'sandy', 'sandy@squirrelpower.org'), (1, 'spongebob', 'spongebob@sqlalchemy.org')]

ROLLBACK

上图是 FunctionElement.over.partition_by 参数，以便 PARTITION BY 该条款在OVER条款内呈现。我们也可以利用 ORDER BY 子句使用 FunctionElement.over.order_by ：

>>> stmt = select(

... func.count().over(order_by=user_table.c.name),

... user_table.c.name,

... address_table.c.email_address).select_from(user_table).join(address_table)

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT count(*) OVER (ORDER BY user_account.name) AS anon_1,

user_account.name, address.email_address

FROM user_account JOIN address ON user_account.id = address.user_id

[...] ()

[(2, 'sandy', 'sandy@sqlalchemy.org'), (2, 'sandy', 'sandy@squirrelpower.org'), (3, 'spongebob', 'spongebob@sqlalchemy.org')]

ROLLBACK

窗口函数的其他选项包括范围的使用；请参见 over() 查看更多示例。

小技巧

需要注意的是， FunctionElement.over() 方法仅应用于那些实际上是聚合函数的SQL函数；而 Over 构造将很高兴地为任何给定的SQL函数呈现自身，如果该函数本身不是SQL聚合函数，则数据库将拒绝该表达式。

集团内特殊修改器，过滤

“组内”SQL语法与“有序集”或“假设集”聚合函数一起使用。常见的“有序集”函数包括 percentile_cont() 和 rank() 。SQLAlChemy包括内置实现 rank ， dense_rank ， mode ， percentile_cont 和 percentile_disc 其中包括一

个 FunctionElement.within_group() 方法：

>>> print(

... func.unnest(

... func.percentile_disc([0.25,0.5,0.75,1]).within_group(user_table.c.name)

... )

unnest(percentile_disc(:percentile_disc_1) WITHIN GROUP (ORDER BY user_account.name))

某些后端支持“过滤”，以将聚合函数的范围限制为与返回的总行范围相比的特定行子集，可使用 FunctionElement.filter() 方法：

>>> stmt = select(

... func.count(address_table.c.email_address).filter(user_table.c.name == 'sandy'),

... func.count(address_table.c.email_address).filter(user_table.c.name == 'spongebob')

... ).select_from(user_table).join(address_table)

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT count(address.email_address) FILTER (WHERE user_account.name = ?) AS anon_1,

count(address.email_address) FILTER (WHERE user_account.name = ?) AS anon_2

FROM user_account JOIN address ON user_account.id = address.user_id

[...] ('sandy', 'spongebob')

[(2, 1)]

ROLLBACK

表值函数

表值SQL函数支持包含命名子元素的标量表示。通常用于JSON和面向数组的函数，以及 generate_series() ，表值函数在FROM子句中指定，然后作为表引用，有时甚至作为列引用。这种形式的函数在PostgreSQL数据库中非常突

出，但是SQLite、Oracle和SQL Server也支持某些形式的表值函数。

参见

表值、表值函数和列值函数、行和元组对象 -在《PostgreSQL》文档。

虽然许多数据库支持表值和其他特殊形式，但PostgreSQL往往是对这些功能需求最大的地方。有关PostgreSQL语法的其他示例以及其他功能，请参阅本节。

SQLAlChemy提供了 FunctionElement.table_valued() 方法作为基本的“表值函数”构造，它将把一个 func 对象添加到包含一系列命名列的FROM子句中，该方法基于按位置传递的字符串名称。这将返回一个 TableValuedAlias 对

象，该对象是启用功能的 Alias 可以用作任何其他FROM子句的构造，如使用别名。下面我们将说明 json_each() 函数，虽然该函数在PostgreSQL上很常见，但SQLite的现代版本也支持该函数：

>>> onetwothree = func.json_each('["one", "two", "three"]').table_valued("value")

>>> stmt = select(onetwothree).where(onetwothree.c.value.in_(["two", "three"]))

>>> with engine.connect() as conn:

... result = conn.execute(stmt)

... print(result.all())

BEGIN (implicit)

SELECT anon_1.value

FROM json_each(?) AS anon_1

WHERE anon_1.value IN (?, ?)

[...] ('["one", "two", "three"]', 'two', 'three')

[('two',), ('three',)]

ROLLBACK

在上面，我们使用了 json_each() SQLite和PostgreSQL支持的JSON函数，用于生成表值表达式，其中单个列引用为 value ，然后选择其三行中的两行。

参见

表值函数 -在《PostgreSQL》文档-本节将详细介绍其他语法，如已知可与PostgreSQL一起使用的特殊列派生和“具有序号”。

列值函数-作为标量列的表值函数

PostgreSQL和Oracle支持的一种特殊语法是引用FROM子句中的函数，然后该函数作为SELECT语句或其他列表达式上下文的COLUMNS子句中的单个列交付。PostgreSQL在以下函数中大量使用此语法 json_array_elements() ，

json_object_keys() ， json_each_text() ， json_each() 等。

SQLAlChemy将其称为“列值”函数，可通过应用 FunctionElement.column_valued() 修饰符设置为 Function 构造：：

>>> from sqlalchemy import select, func

>>> stmt = select(func.json_array_elements('["one", "two"]').column_valued("x"))

>>> print(stmt)

SELECT x

FROM json_array_elements(:json_array_elements_1) AS x

Oracle方言也支持“Column Valued”表单，它可用于自定义SQL函数：

>>> from sqlalchemy.dialects import oracle

>>> stmt = select(func.scalar_strings(5).column_valued("s"))

>>> print(stmt.compile(dialect=oracle.dialect()))

SELECT COLUMN_VALUE s

FROM TABLE (scalar_strings(:scalar_strings_1)) s

参见

列值函数 -在《PostgreSQL》文档。

SQLAlchemy 1.4 / 2.0 Tutorial

下一教程部分：使用核心更新和删除行

分享到微博

使用核心更新和删除行

SQLAlchemy 1.4 / 2.0 Tutorial

此页是 SQLAlchemy 1.4/2.0教程。

上一次：使用核心或ORM选择行 |下一步： |next|

使用核心更新和删除行

到目前为止，我们已经讨论过 Insert ，这样我们就可以将一些数据放入我们的数据库中，然后花费大量时间在 Select 其处理用于从数据库检索数据的广泛的使用模式。在本节中，我们将介绍 Update 和 Delete 构造，这些构造

用于修改现有行以及删除现有行。本节将从以核心为中心的角度介绍这些构造。

ORM阅读器阅读器 -正如在插入带核心的行，即 Update 和 Delete 与ORM一起使用时，操作通常从 Session 对象作为 unit of work 进程。

然而，与之不同的是， Insert ，即 Update 和 Delete 构造也可以直接与ORM一起使用，使用一种称为“支持ORM的更新和删除”的模式；因此，熟悉这些构造对于ORM的使用很有用。这两种使用方式都在各节中进行了讨论。更新

ORM对象和删除ORM对象。

update()SQL表达式构造

这个 update() 函数会生成 Update 它表示SQL中的UPDATE语句，它将更新表中的现有数据。

就像 insert() 构造，有一种“传统”形式的 update() ，它一次针对一个表发出UPDATE，并且不返回任何行。但是，一些后端支持可以一次修改多个表的UPDATE语句，并且UPDATE语句还支持返回，以便匹配行中包含的列可以在

结果集中返回。

基本更新如下：：

>>> from sqlalchemy import update

>>> stmt = (

... update(user_table).where(user_table.c.name == 'patrick').

... values(fullname='Patrick the Star')

... )

>>> print(stmt)

UPDATE user_account SET fullname=:fullname WHERE user_account.name = :name_1

这个 Update.values() 方法控制UPDATE语句的Set元素的内容。这与 Insert 构造。通常可以使用列名作为关键字参数来传递参数。

UPDATE支持所有主要的SQL形式的UPDATE，包括针对表达式的UPDATE，我们可以使用 Column 表达式：：

>>> stmt = (

... update(user_table).

... values(fullname="Username: " + user_table.c.name)

... )

>>> print(stmt)

UPDATE user_account SET fullname=(:name_1 || user_account.name)

为了在“ecutemany”上下文中支持UPDATE，在该上下文中，将针对同一语句调用多个参数集， bindparam() 构造可用于设置绑定参数；这些参数替换了文本值通常所在的位置：

>>> from sqlalchemy import bindparam

>>> stmt = (

... update(user_table).

... where(user_table.c.name == bindparam('oldname')).

... values(name=bindparam('newname'))

... )

>>> with engine.begin() as conn:

... conn.execute(

... stmt,

... [

... {'oldname':'jack', 'newname':'ed'},

... {'oldname':'wendy', 'newname':'mary'},

... {'oldname':'jim', 'newname':'jake'},

... ]

... )

BEGIN (implicit)

UPDATE user_account SET name=? WHERE user_account.name = ?

[...] (('ed', 'jack'), ('mary', 'wendy'), ('jake', 'jim'))

<sqlalchemy.engine.cursor.CursorResult object at 0x...>

COMMIT

可应用于更新的其他技术包括：

SQLAlchemy ORM教程：Python数据库访问神器

SQLAlchemy 0.8.7 官方文档概述与教程

Django集成SQLAlchemy教程：轻松操作数据库

SQLAlchemy教程详解：从入门到高级查询

sqlalchemy documentation sqlalchemy 文档

sqlalchemy 英文文档

sqlalchemy官方文档

Python实现自动组卷评卷考试系统源码+报告文档+使用教程.zip

sqlalchemy文档资料翻译

sqlalchemy

基于Flask的二手物品交易平台（源码+数据库脚本+说明文档+视频演示）.rar

最新资源