SQLAlchemy 1.4 Documentation

Connection.execution_options()

method sqlalchemy.ext.asyncio.AsyncEngine.update_execution_options(**opt)¶

更新此的默认执行选项字典 Engine .

代表 Engine 代表 AsyncEngine 班级。

中给定的键/值 * *opt被添加到将用于所有连接的默认执行选项中。本词典的初始内容可通过 execution_options 参数到 create_engine() .

参见

Engine.execution_options()

class sqlalchemy.ext.asyncio.AsyncConnection(async_engine, sync_connection=None)¶

的异步代理 Connection .

AsyncConnection 是使用 AsyncEngine.connect() 方法 AsyncEngine ：：

from sqlalchemy.ext.asyncio import create_async_engine
engine = create_async_engine("postgresql+asyncpg://user:pass@host/dbname")

async with engine.connect() as conn:
    result = await conn.execute(select(table))

1.4 新版功能.

类签名

class sqlalchemy.ext.asyncio.AsyncConnection (sqlalchemy.ext.asyncio.base.ProxyComparable, sqlalchemy.ext.asyncio.base.StartableContext, sqlalchemy.ext.asyncio.AsyncConnectable)

method sqlalchemy.ext.asyncio.AsyncConnection.begin()¶: 在自动注册之前开始事务。

method sqlalchemy.ext.asyncio.AsyncConnection.begin_nested()¶: 开始嵌套事务并返回事务句柄。

async method sqlalchemy.ext.asyncio.AsyncConnection.close()¶

关闭此 AsyncConnection .

如果有事务，这也有回滚事务的效果。

async method sqlalchemy.ext.asyncio.AsyncConnection.commit()¶

提交当前正在进行的事务。

此方法提交当前事务（如果已启动）。如果没有启动任何事务，则假定连接处于非无效状态，则该方法无效。

交易开始于 Connection 当第一次执行语句时自动执行，或者 Connection.begin() 方法被调用。

attribute sqlalchemy.ext.asyncio.AsyncConnection.connection¶: 没有为异步实现；调用 AsyncConnection.get_raw_connection() .

async method sqlalchemy.ext.asyncio.AsyncConnection.exec_driver_sql(statement, parameters=None, execution_options={})¶: 执行驱动程序级别的SQL字符串并返回缓冲区 Result .

async method sqlalchemy.ext.asyncio.AsyncConnection.execute(statement, parameters=None, execution_options={})¶

执行SQL语句构造并返回缓冲区 Result .

参数

object¶ --
要执行的语句。这始终是一个同时位于 ClauseElement 和 Executable 层次结构，包括：
- Select
- Insert, Update, Delete
- TextClause and TextualSelect
- DDL and objects which inherit from DDLElement
parameters¶ -- 将绑定到语句中的参数。这可以是参数名到值的字典，也可以是字典的可变序列（例如列表）。当传递字典列表时，底层语句执行将使用DBAPI cursor.executemany() 方法。当传递单个字典时，DBAPI cursor.execute() 方法。
execution_options¶ -- 执行选项的可选字典，它将与语句执行关联。此字典可以提供接受的选项的子集 Connection.execution_options() .

返回

一 Result 对象。

async method sqlalchemy.ext.asyncio.AsyncConnection.execution_options(**opt)¶

为在执行期间生效的连接设置非SQL选项。

这个返回这个 AsyncConnection 对象添加了新选项。

见 Connection.execution_options() 有关此方法的详细信息。

method sqlalchemy.ext.asyncio.AsyncConnection.get_nested_transaction()¶

返回一个 AsyncTransaction 表示当前嵌套(保存点)事务(如果有)。

这利用了底层同步连接的 Connection.get_nested_transaction() 方法来获取当前 Transaction ，然后在新的 AsyncTransaction 对象。

1.4.0b2 新版功能.

async method sqlalchemy.ext.asyncio.AsyncConnection.get_raw_connection()¶

返回此使用的池DBAPI级别连接 AsyncConnection .

这是SQLAlChemy连接池代理连接，然后该连接具有属性 _ConnectionFairy.driver_connection 这指的是实际的驱动程序连接。它的 _ConnectionFairy.dbapi_connection 而是指一个 AdaptedConnection 实例，该实例使驱动程序连接适应DBAPI协议。

method sqlalchemy.ext.asyncio.AsyncConnection.get_transaction()¶

返回一个 AsyncTransaction 表示当前事务(如果有)的。

这利用了底层同步连接的 Connection.get_transaction() 方法来获取当前 Transaction ，然后在新的 AsyncTransaction 对象。

1.4.0b2 新版功能.

method sqlalchemy.ext.asyncio.AsyncConnection.in_nested_transaction()¶: 如果事务正在进行，则返回True。

1.4.0b2 新版功能.

method sqlalchemy.ext.asyncio.AsyncConnection.in_transaction()¶: 如果事务正在进行，则返回True。

1.4.0b2 新版功能.

attribute sqlalchemy.ext.asyncio.AsyncConnection.info¶

返回 Connection.info 基础数据库的字典 Connection 。

对于与数据库连接相关联的用户定义状态，此字典可以自由写入。

此属性仅在以下情况下可用 AsyncConnection 当前已连接。如果 AsyncConnection.closed 属性为 True ，则访问此属性将引发 ResourceClosedError 。

1.4.0b2 新版功能.

async method sqlalchemy.ext.asyncio.AsyncConnection.invalidate(exception=None)¶

使与此关联的基础DBAPI连接失效 Connection .

见方法 Connection.invalidate() 关于这个方法的全部细节。

async method sqlalchemy.ext.asyncio.AsyncConnection.rollback()¶

回滚当前正在进行的事务。

如果当前事务已启动，此方法将回滚当前事务。如果没有启动任何事务，则该方法无效。如果事务已启动且连接处于无效状态，则使用此方法清除该事务。

交易开始于 Connection 当第一次执行语句时自动执行，或者 Connection.begin() 方法被调用。

async method sqlalchemy.ext.asyncio.AsyncConnection.run_sync(fn, *arg, **kw)¶

调用给定的sync callable passing self作为第一个参数。

此方法通过在一个特殊检测的greenlet中运行给定的callable来维护从到数据库连接的asyncio事件循环。

例如。：：

with async_engine.begin() as conn:
    await conn.run_sync(metadata.create_all)

注解

提供的Callable在异步事件循环内内联调用，并将在传统IO调用上挡路。此可调用对象中的IO应该只调用SQLAlChemy的异步数据库API，这些API将适当地适应greenlet上下文。

参见

在Asyncio下运行同步方法和函数

async method sqlalchemy.ext.asyncio.AsyncConnection.scalar(statement, parameters=None, execution_options={})¶

执行SQL语句构造并返回标量对象。

此方法是调用 Result.scalar() 方法调用 Connection.execute() 方法。参数是等效的。

返回: 一个标量Python值，表示返回的第一行的第一列。

async method sqlalchemy.ext.asyncio.AsyncConnection.scalars(statement, parameters=None, execution_options={})¶

执行SQL语句构造并返回标量对象。

此方法是调用 Result.scalars() 在调用 Connection.execute() 方法。参数是等效的。

返回: 一个 ScalarResult 对象。

1.4.24 新版功能.

async method sqlalchemy.ext.asyncio.AsyncConnection.start(is_ctxmanager=False)¶: 开始吧 AsyncConnection 对象的上下文在使用Python之外 with: 块。

async method sqlalchemy.ext.asyncio.AsyncConnection.stream(statement, parameters=None, execution_options={})¶: 执行语句并返回流 AsyncResult 对象。

async method sqlalchemy.ext.asyncio.AsyncConnection.stream_scalars(statement, parameters=None, execution_options={})¶

执行SQL语句并返回流式标量结果对象。

此方法是调用 AsyncResult.scalars() 在调用 Connection.stream() 方法。参数是等效的。

返回: 一个 AsyncScalarResult 对象。

1.4.24 新版功能.

attribute sqlalchemy.ext.asyncio.AsyncConnection.sync_connection¶

对同步样式的引用 Connection 这 AsyncConnection 代理请求指向。

此实例可以用作事件目标。

参见

attribute sqlalchemy.ext.asyncio.AsyncConnection.sync_engine¶

对同步样式的引用 Engine 这 AsyncConnection 通过其基础结构与 Connection 。

此实例可以用作事件目标。

参见

AsyncResult.partitions()

class sqlalchemy.ext.asyncio.AsyncTransaction(connection, nested=False)¶

的异步代理 Transaction .

类签名

class sqlalchemy.ext.asyncio.AsyncTransaction (sqlalchemy.ext.asyncio.base.ProxyComparable, sqlalchemy.ext.asyncio.base.StartableContext)

async method sqlalchemy.ext.asyncio.AsyncTransaction.close()¶

关闭此 Transaction .

如果此事务是begin/commit嵌套中的基本事务，则该事务将回滚（）。否则，方法返回。

这用于取消事务，而不影响封闭事务的范围。

async method sqlalchemy.ext.asyncio.AsyncTransaction.commit()¶: 提交此 Transaction .

async method sqlalchemy.ext.asyncio.AsyncTransaction.rollback()¶: 回滚这个 Transaction .

async method sqlalchemy.ext.asyncio.AsyncTransaction.start(is_ctxmanager=False)¶: 开始吧 AsyncTransaction 对象的上下文在使用Python之外 with: 块。

结果集API文档¶

这个 AsyncResult 对象是 Result 对象。只有在使用 AsyncConnection.stream() 或 AsyncSession.stream() 方法，返回位于活动数据库游标顶部的结果对象。

Object Name	Description
AsyncMappingResult	包装纸 `AsyncResult` 返回字典值而不是 `Row` 价值观。
AsyncResult	一个异步包装器 `Result` 对象。
AsyncScalarResult	包装纸 `AsyncResult` 返回标量值而不是 `Row` 价值观。

class sqlalchemy.ext.asyncio.AsyncResult(real_result)¶

一个异步包装器 Result 对象。

这个 AsyncResult 仅适用于使用服务器端游标的语句执行。它只从 AsyncConnection.stream() 和 AsyncSession.stream() 方法。

注解

就像现在的情况一样 Result ，此对象用于由返回的ORM结果 AsyncSession.execute() ，它可以单独生成ORM映射对象的实例，也可以在类似元组的行内生成ORM映射对象的实例。请注意，这些结果对象不会像传统的那样自动消除实例或行的重复数据 Query 对象。对于实例或行的Python内重复数据消除，请使用 AsyncResult.unique() 修饰符方法。

1.4 新版功能.

类签名

class sqlalchemy.ext.asyncio.AsyncResult (sqlalchemy.ext.asyncio.AsyncCommon)

async method sqlalchemy.ext.asyncio.AsyncResult.all()¶

返回列表中的所有行。

调用后关闭结果集。随后的调用将返回一个空列表。

返回: 一览表 Row 物体。

method sqlalchemy.ext.asyncio.AsyncResult.columns(*col_expressions)¶

建立每行中应返回的列。

参照 Result.columns() 在同步SQLAlchemy API中获取完整的行为描述。

async method sqlalchemy.ext.asyncio.AsyncResult.fetchmany(size=None)¶

取许多行。

当所有行都用完时，返回一个空列表。

与AlchemY.1.1兼容。

要获取组中的行，请使用 AsyncResult.partitions() 方法。

返回: 一览表 Row 物体。

参见

async method sqlalchemy.ext.asyncio.AsyncResult.fetchone()¶

取一行。

当所有行都用完时，返回None。

与AlchemY.1.1兼容。

要只获取结果的第一行，请使用 Result.first() 方法。要遍历所有行，请迭代 Result 直接对象。

返回: 一 Row 对象（如果未应用筛选器），或者如果没有保留行，则为无。

async method sqlalchemy.ext.asyncio.AsyncResult.first()¶

获取第一行，如果没有行，则不获取。

关闭结果集并丢弃其余行。

注解

此方法返回一个 row ，例如，默认情况下是元组。要只返回一个标量值，即第一行的第一列，请使用 AsyncResult.scalar() 方法或组合 AsyncResult.scalars() 和 AsyncResult.first() .

返回: 一 Row 对象，如果没有行保留，则无。

参见

AsyncResult.scalar()

AsyncResult.one()

async method sqlalchemy.ext.asyncio.AsyncResult.freeze()¶

返回一个可调用的对象，该对象将生成此 AsyncResult 当被调用时。

返回的可调用对象是 FrozenResult .

这用于结果集缓存。当结果尚未使用时，必须对其调用该方法，而调用该方法将完全消耗结果。当 FrozenResult 从缓存中检索时，可以多次调用它，其中它将生成一个新的 Result 对象每次针对其存储的行集。

参见

重新执行语句 -ORM中实现结果集缓存的示例用法。

method sqlalchemy.ext.asyncio.AsyncResult.keys()¶: 返回 Result.keys() 从底层收集 Result .

method sqlalchemy.ext.asyncio.AsyncResult.mappings()¶

对返回的行应用映射筛选器，返回 AsyncMappingResult .

应用此筛选器时，获取行将返回 RowMapping 对象而不是 Row 物体。

参照 Result.mappings() 在同步SQLAlchemy API中获取完整的行为描述。

返回: 一个新的 AsyncMappingResult 筛选引用基础 Result 对象。

method sqlalchemy.ext.asyncio.AsyncResult.merge(*others)¶

合并此 AsyncResult 与其他兼容的结果对象。

返回的对象是的实例 MergedResult 给定的迭代器将由以下对象组成。

新结果将使用此结果对象中的元数据。后续的结果对象必须针对相同的结果/游标元数据集，否则行为未定义。

async method sqlalchemy.ext.asyncio.AsyncResult.one()¶

只返回一行或引发异常。

加薪 NoResultFound 如果结果没有返回行，或者 MultipleResultsFound 如果返回多行。

注解

此方法返回一个 row ，例如，默认情况下是元组。要只返回一个标量值，即第一行的第一列，请使用 AsyncResult.scalar_one() 方法或组合 AsyncResult.scalars() 和 AsyncResult.one() .

1.4 新版功能.

返回: 第一 Row .
加薪: MultipleResultsFound, NoResultFound

参见

AsyncResult.first()

AsyncResult.one_or_none()

AsyncResult.scalar_one()

async method sqlalchemy.ext.asyncio.AsyncResult.one_or_none()¶

最多返回一个结果或引发异常。

返回 None 如果结果没有行。加薪 MultipleResultsFound 如果返回多行。

1.4 新版功能.

返回: 第一 Row 如果没有行可用，则无。
加薪: MultipleResultsFound

参见

AsyncResult.first()

AsyncResult.one()

method sqlalchemy.ext.asyncio.AsyncResult.partitions(size=None)¶

迭代给定大小的行的子列表。

返回异步迭代器：：

async def scroll_results(connection):
    result = await connection.stream(select(users_table))

    async for partition in result.partitions(100):
        print("list of rows: %s" % partition)

参见

Result.partitions()

async method sqlalchemy.ext.asyncio.AsyncResult.scalar()¶

获取第一行的第一列，并关闭结果集。

如果没有要获取的行，则返回None。

不执行验证来测试是否还有其他行。

调用此方法后，对象将完全关闭，例如 CursorResult.close() 将调用方法。

返回: Python标量值，如果没有行保留，则为无。

async method sqlalchemy.ext.asyncio.AsyncResult.scalar_one()¶

只返回一个标量结果或引发异常。

这相当于调用 AsyncResult.scalars() 然后 AsyncResult.one() 。

参见

AsyncResult.one()

AsyncResult.scalars()

async method sqlalchemy.ext.asyncio.AsyncResult.scalar_one_or_none()¶

只返回一个或不返回标量结果。

这相当于调用 AsyncResult.scalars() 然后 AsyncResult.one_or_none() 。

参见

AsyncResult.one_or_none()

AsyncResult.scalars()

method sqlalchemy.ext.asyncio.AsyncResult.scalars(index=0)¶

返回一 AsyncScalarResult 将返回单个元素而不是 Row 物体。

参照 Result.scalars() 在同步SQLAlchemy API中获取完整的行为描述。

参数: index¶ -- 整数或行键，指示要从每行提取的列，默认为 0 表示第一列。
返回: 一个新的 AsyncScalarResult 引用此的筛选对象 AsyncResult 对象。

method sqlalchemy.ext.asyncio.AsyncResult.unique(strategy=None)¶

对此返回的对象应用唯一筛选 AsyncResult .

参照 Result.unique() 在同步SQLAlchemy API中获取完整的行为描述。

class sqlalchemy.ext.asyncio.AsyncScalarResult(real_result, index)¶

包装纸 AsyncResult 返回标量值而不是 Row 价值观。

这个 AsyncScalarResult 对象是通过调用 AsyncResult.scalars() 方法。

参考 ScalarResult 对象，以获取完整的行为描述。

1.4 新版功能.

类签名

class sqlalchemy.ext.asyncio.AsyncScalarResult (sqlalchemy.ext.asyncio.AsyncCommon)

async method sqlalchemy.ext.asyncio.AsyncScalarResult.all()¶

返回列表中的所有标量值。

相当于 AsyncResult.all() 除了标量值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncScalarResult.fetchall()¶: 的同义词 AsyncScalarResult.all() 方法。

async method sqlalchemy.ext.asyncio.AsyncScalarResult.fetchmany(size=None)¶

获取许多对象。

相当于 AsyncResult.fetchmany() 除了标量值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncScalarResult.first()¶

获取第一个对象，如果没有对象，则不获取。

相当于 AsyncResult.first() 除了标量值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncScalarResult.one()¶

只返回一个对象或引发异常。

相当于 AsyncResult.one() 除了标量值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncScalarResult.one_or_none()¶

最多返回一个对象或引发异常。

相当于 AsyncResult.one_or_none() 除了标量值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncScalarResult.partitions(size=None)¶

迭代给定大小的元素的子列表。

相当于 AsyncResult.partitions() 除了标量值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncScalarResult.unique(strategy=None)¶

对此返回的对象应用唯一筛选 AsyncScalarResult .

见 AsyncResult.unique() 有关用法的详细信息。

class sqlalchemy.ext.asyncio.AsyncMappingResult(result)¶

包装纸 AsyncResult 返回字典值而不是 Row 价值观。

这个 AsyncMappingResult 对象是通过调用 AsyncResult.mappings() 方法。

参考 MappingResult 对象，以获取完整的行为描述。

1.4 新版功能.

类签名

class sqlalchemy.ext.asyncio.AsyncMappingResult (sqlalchemy.ext.asyncio.AsyncCommon)

async method sqlalchemy.ext.asyncio.AsyncMappingResult.all()¶

返回列表中的所有标量值。

相当于 AsyncResult.all() 除了映射值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncMappingResult.columns(*col_expressions)¶: 建立每行中应返回的列。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.fetchall()¶: 的同义词 AsyncMappingResult.all() 方法。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.fetchmany(size=None)¶

获取许多对象。

相当于 AsyncResult.fetchmany() 除了映射值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.fetchone()¶

取一个对象。

相当于 AsyncResult.fetchone() 除了映射值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.first()¶

获取第一个对象，如果没有对象，则不获取。

相当于 AsyncResult.first() 除了映射值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncMappingResult.keys()¶

返回一个iterable视图，该视图生成由每个键表示的字符串键 Row .

还可以使用Python测试视图的密钥包含 in 运算符，它将测试视图中表示的字符串键以及可选键（如列对象）。

在 1.4 版更改: 返回键视图对象而不是纯列表。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.one()¶

只返回一个对象或引发异常。

相当于 AsyncResult.one() 除了映射值，而不是 Row 对象，则返回。

async method sqlalchemy.ext.asyncio.AsyncMappingResult.one_or_none()¶

最多返回一个对象或引发异常。

相当于 AsyncResult.one_or_none() 除了映射值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncMappingResult.partitions(size=None)¶

迭代给定大小的元素的子列表。

相当于 AsyncResult.partitions() 除了映射值，而不是 Row 对象，则返回。

method sqlalchemy.ext.asyncio.AsyncMappingResult.unique(strategy=None)¶

对此返回的对象应用唯一筛选 AsyncMappingResult .

见 AsyncResult.unique() 有关用法的详细信息。

ORM会话API文档¶

Object Name	Description
async_object_session(instance)	返回 `AsyncSession` 给定实例所属的。
async_scoped_session	提供范围内的管理 `AsyncSession` 对象。
async_session(session)	返回 `AsyncSession` 它代理给定的 `Session` 对象(如果有)。
AsyncSession	的异步版本 `Session` .
AsyncSessionTransaction	ORM的包装 `SessionTransaction` 对象。

function sqlalchemy.ext.asyncio.async_object_session(instance)¶

返回 AsyncSession 给定实例所属的。

此函数利用sync-api函数 object_session 检索 Session 它引用给定的实例，并从那里将其链接到原始实例 AsyncSession 。

如果 AsyncSession 已被垃圾回收，则返回值为 None 。

此功能也可以从 InstanceState.async_session 访问者。

参数: instance¶ -- ORM映射的实例
返回: 一个 AsyncSession 对象，或 None 。

1.4.18 新版功能.

function sqlalchemy.ext.asyncio.async_session(session)¶

返回 AsyncSession 它代理给定的 Session 对象(如果有)。

参数: session¶ -- 一个 Session 实例。
返回: 一个 AsyncSession 实例，或 None 。

1.4.18 新版功能.

class sqlalchemy.ext.asyncio.async_scoped_session(session_factory, scopefunc)¶

提供范围内的管理 AsyncSession 对象。

请参阅部分使用异步作用域会话有关用法详细信息，请参阅。

1.4.19 新版功能.

类签名

class sqlalchemy.ext.asyncio.async_scoped_session (sqlalchemy.orm.scoping.ScopedSessionMixin)

method sqlalchemy.ext.asyncio.async_scoped_session.__call__(**kw)¶

inherited from the sqlalchemy.orm.scoping.ScopedSessionMixin.__call__ method of ScopedSessionMixin

返回当前 Session ，使用 scoped_session.session_factory 如果不在场的话。

参数: **kw¶ -- 关键字参数将传递给 scoped_session.session_factory 如果现有的 Session 不存在。如果 Session 并且已经传递了关键字参数， InvalidRequestError 都被养大了。

method sqlalchemy.ext.asyncio.async_scoped_session.__init__(session_factory, scopefunc)¶

构建新的 async_scoped_session 。

参数

session_factory¶ -- 一家工厂将创造新的 AsyncSession 实例。这通常(但不一定)是 sessionmaker ，它本身被传递给 AsyncSession 至其 sessionmaker.class_ 参数：：Async_SESSION_FACTORY=sessionaker(Some_Async_Engine，class_=AsyncSession)AsyncSession=Async_Scope_Session(Async_Session_Factory，scope efunc=CURRENT_TASK)
scopefunc¶ -- 定义当前作用域的函数。函数，如 asyncio.current_task 在这里可能有用。

method sqlalchemy.ext.asyncio.async_scoped_session.add(instance, _warn=True)¶

将对象放置在 Session .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

它的状态将在下次刷新操作时保留到数据库中。

重复呼叫 add() 将被忽略。相反的 add() 是 expunge() .

method sqlalchemy.ext.asyncio.async_scoped_session.add_all(instances)¶: 将给定的实例集合添加到此 Session .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.async_scoped_session.autoflush¶: 代理用于 AsyncSession 类代表 async_scoped_session 班级。

method sqlalchemy.ext.asyncio.async_scoped_session.begin(**kw)¶

返回一 AsyncSessionTransaction 对象。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

底层 Session 将执行“开始”操作时 AsyncSessionTransaction 输入对象：

async with async_session.begin():
    # .. ORM transaction is begun

请注意，数据库IO通常不会在会话级事务开始时发生，因为数据库事务是按需开始的。但是，begin块是异步的，以适应 SessionEvents.after_transaction_create() 可能执行IO的事件钩子。

有关ORM begin的一般描述，请参见 Session.begin() .

method sqlalchemy.ext.asyncio.async_scoped_session.begin_nested(**kw)¶

返回一 AsyncSessionTransaction 对象，它将开始一个“嵌套”事务，例如SAVEPOINT。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

行为与 AsyncSession.begin() .

有关ORM begin nested的一般说明，请参阅 Session.begin_nested() .

method sqlalchemy.ext.asyncio.async_scoped_session.close()¶

关闭此对象使用的事务性资源和ORM对象 AsyncSession 。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

这将删除与此关联的所有ORM对象 AsyncSession ，结束正在进行的任何事务，并 releases 任何 AsyncConnection 此对象 AsyncSession 本身已从关联的 AsyncEngine 对象。然后，该操作将 AsyncSession 处于可以再次使用的状态。

小技巧

这个 AsyncSession.close() 方法 不会阻止再次使用该会话 。这个 AsyncSession 本身实际上并不具有明显的“关闭”状态；它只是表示 AsyncSession 将释放所有数据库连接和ORM对象。

参见

关闭 - detail on the semantics of AsyncSession.close()

method sqlalchemy.ext.asyncio.async_scoped_session.classmethod close_all()¶: 全部关闭 AsyncSession 会议。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

method sqlalchemy.ext.asyncio.async_scoped_session.commit()¶: 提交当前正在进行的事务。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

method sqlalchemy.ext.asyncio.async_scoped_session.configure(**kwargs)¶

inherited from the ScopedSessionMixin.configure() method of ScopedSessionMixin

重新配置 sessionmaker 由此使用 scoped_session 。

看见 sessionmaker.configure() 。

method sqlalchemy.ext.asyncio.async_scoped_session.connection(**kw)¶

返回A AsyncConnection 与此对应的对象 Session 对象的事务状态。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

此方法还可用于为当前事务使用的数据库连接建立执行选项。

1.4.24 新版功能: 添加了**kw参数，这些参数将传递到基础 Session.connection() 方法。

参见

Session.connection() -“连接”的主要文档

method sqlalchemy.ext.asyncio.async_scoped_session.delete(instance)¶

将实例标记为已删除。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

数据库删除操作发生在 flush() .

由于此操作可能需要沿着卸载的关系级联，因此允许发生这些查询是可以等待的。

参见

Session.delete() -删除的主要文档

attribute sqlalchemy.ext.asyncio.async_scoped_session.deleted¶: 此中标记为“已删除”的所有实例的集合 Session

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.async_scoped_session.dirty¶

所有持久实例的集合被认为是脏的。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

例如。：：

some_mapped_object in session.dirty

实例在被修改但未被删除时被视为脏实例。

请注意，此“脏”计算是“乐观的”；大多数属性设置或集合修改操作都会将实例标记为“脏”并将其放置在此集合中，即使属性值没有净更改。在刷新时，将每个属性的值与以前保存的值进行比较，如果没有净更改，则不会发生SQL操作（这是一个更昂贵的操作，因此只在刷新时进行）。

要检查实例是否对其属性进行了可操作的网络更改，请使用 Session.is_modified() 方法。

method sqlalchemy.ext.asyncio.async_scoped_session.execute(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 执行语句并返回缓冲区 Result 对象。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

参见

Session.execute() -执行的主要文档

method sqlalchemy.ext.asyncio.async_scoped_session.expire(instance, attribute_names=None)¶

使实例上的属性过期。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

将实例的属性标记为过期。下次访问过期属性时，将向 Session 对象的当前事务上下文，以便加载给定实例的所有过期属性。请注意，高度隔离的事务将返回与以前在同一事务中读取的值相同的值，而不考虑该事务外数据库状态的更改。

使中的所有对象过期 Session 同时，使用 Session.expire_all() .

这个 Session 对象的默认行为是在 Session.rollback() 或 Session.commit() 方法，以便可以为新事务加载新状态。为此，请致电 Session.expire() 只有在当前事务中发出非ORM SQL语句的特定情况下才有意义。

参数

instance¶ -- 要刷新的实例。
attribute_names¶ -- 指示要过期的属性子集的字符串属性名称的可选列表。

参见

刷新/过期 -介绍性材料

method sqlalchemy.ext.asyncio.async_scoped_session.expire_all()¶

使此会话中的所有永久实例过期。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

下次访问持久实例上的任何属性时，将使用 Session 对象的当前事务上下文，以便加载给定实例的所有过期属性。请注意，高度隔离的事务将返回与以前在同一事务中读取的值相同的值，而不考虑该事务外数据库状态的更改。

要使这些对象上的单个对象和单个属性过期，请使用 Session.expire() .

这个 Session 对象的默认行为是在 Session.rollback() 或 Session.commit() 方法，以便可以为新事务加载新状态。为此，请致电 Session.expire_all() 当自动提交为 False ，假设事务是独立的。

参见

刷新/过期 -介绍性材料

“由于在刷新过程中出现以前的异常，此会话的事务已回滚。”（或类似）

method sqlalchemy.ext.asyncio.async_scoped_session.expunge(instance)¶

移除 instance 由此 Session .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

这将释放对该实例的所有内部引用。将根据删去级联规则。

method sqlalchemy.ext.asyncio.async_scoped_session.expunge_all()¶

从此中删除所有对象实例 Session .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

这相当于呼叫 expunge(obj) 在所有对象上 Session .

method sqlalchemy.ext.asyncio.async_scoped_session.flush(objects=None)¶: 将所有对象更改刷新到数据库。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

参见

Session.flush() -同花顺的主要文档

method sqlalchemy.ext.asyncio.async_scoped_session.get(entity, ident, options=None, populate_existing=False, with_for_update=None, identity_token=None)¶: 根据给定的主键标识符返回实例，或者 None 如果找不到的话。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

参见

Session.get() -GET的主要文档

method sqlalchemy.ext.asyncio.async_scoped_session.get_bind(mapper=None, clause=None, bind=None, _sa_skip_events=None, _sa_skip_for_implicit_returning=False)¶

返回一个“绑定”，此 Session 是绑定的。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

“bind”通常是 Engine ，除非 Session 已直接绑定到 Connection .

对于多重绑定或未绑定 Session , the mapper 或 clause 参数用于确定要返回的适当绑定。

注意，“mapper”参数通常在 Session.get_bind() 通过ORM操作调用，例如 Session.query() ，中的每个插入/更新/删除操作 Session.flush() ，电话等。

决议顺序为：

如果给出映射器并且 Session.binds 如果存在，则首先基于正在使用的映射器，然后基于正在使用的映射类，然后基于中存在的任何基类定位绑定 __mro__ 从更具体的超类到更一般的映射类。
如果给出条款和 Session.binds 存在，则根据 Table 在给定子句中找到的对象存在于 Session.binds .
如果 Session.binds 存在，还那个。
如果给定子句，则尝试返回链接到 MetaData 最终与该条款相关。
如果给定了映射器，则尝试返回链接到 MetaData 最终与 Table 或映射器映射到的其他可选对象。
找不到绑定， UnboundExecutionError 提高了。

请注意 Session.get_bind() 方法可以在的用户定义子类上重写 Session 提供任何类型的绑定解决方案。参见中的示例自定义垂直分区 .

参数

mapper¶ -- 可选的 mapper() 映射的类或实例 Mapper . 绑定可以从 Mapper 首先查阅与此相关联的“绑定”映射 Session 第二，通过咨询 MetaData 与 Table 其中 Mapper 为绑定映射。
clause¶ -- A ClauseElement （即 select() ， text() 等）。如果 mapper 参数不存在或无法生成绑定，将搜索给定的表达式构造以查找绑定元素，通常是 Table 与绑定关联 MetaData .

参见

分区策略（例如，每个会话有多个数据库后端）

Session.binds

Session.bind_mapper()

Session.bind_table()

method sqlalchemy.ext.asyncio.async_scoped_session.classmethod identity_key(*args, **kwargs)¶

返回标识密钥。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

这是的别名 identity_key() .

attribute sqlalchemy.ext.asyncio.async_scoped_session.identity_map¶: 代理用于 AsyncSession 类代表 async_scoped_session 班级。

attribute sqlalchemy.ext.asyncio.async_scoped_session.info¶

用户可修改字典。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

此字典的初始值可以使用 info 论据 Session 构造函数或 sessionmaker 构造函数或工厂方法。这里的字典总是本地的 Session 并且可以独立于所有其他 Session 物体。

attribute sqlalchemy.ext.asyncio.async_scoped_session.is_active¶

如果这是真的 Session 不处于“部分回滚”状态。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

在 1.4 版更改: 这个 Session 不再立即开始新事务，因此当 Session 首先实例化。

“部分回滚”状态通常表示 Session 已经失败了 Session.rollback() 方法才能完全回滚事务。

如果这样 Session 根本不在事务中 Session 第一次使用时会自动注册，所以在本例中 Session.is_active 将返回true。

否则，如果 Session 在事务中，并且该事务尚未在内部回滚，则 Session.is_active 也将返回True。

参见

Session.in_transaction()

method sqlalchemy.ext.asyncio.async_scoped_session.is_modified(instance, include_collections=True)¶

返回 True 如果给定实例具有本地修改的属性。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

此方法检索实例上每个已检测属性的历史记录，并将当前值与其以前提交的值（如果有）进行比较。

实际上，它是在 Session.dirty 集合；对每个属性的网络“脏”状态执行完整测试。

例如。：：

return session.is_modified(someobject)

该方法的一些注意事项适用于：

存在于中的实例 Session.dirty 集合可能报告 False 当用这种方法测试时。这是因为对象可能通过属性突变接收到更改事件，因此将其放入 Session.dirty 但最终状态与从数据库加载的状态相同，因此此处不会发生任何净更改。
在应用新值时，如果在接收到新值时属性未被加载或已过期，则标量属性可能没有记录以前设置的值-在这些情况下，假定该属性发生更改，即使其数据库值最终没有净更改。在大多数情况下，当一个集合事件发生时，sqlAlchemy不需要“old”值，因此如果旧值不存在，它会跳过SQL调用的开销，这是基于通常需要更新标量值的假设，而在少数情况下，它不存在的情况下，平均比发出防御性选择的代价要低。

只有当属性容器具有 active_history 标志设置为 True . 此标志通常为不是简单的多对一的主键属性和标量对象引用设置。要为任意映射列设置此标志，请使用 active_history 争论与 column_property() .

参数

instance¶ -- 要测试的映射实例是否存在挂起的更改。
include_collections¶ -- 指示操作中是否应包含多值集合。设置为 False 是一种只检测本地基于列的属性（即标量列或多对一外键）的方法，在刷新时将导致此实例的更新。

method sqlalchemy.ext.asyncio.async_scoped_session.merge(instance, load=True, options=None)¶: 将给定实例的状态复制到 AsyncSession .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

参见

Session.merge() -合并的主要文档

attribute sqlalchemy.ext.asyncio.async_scoped_session.new¶: 在此中标记为“new”的所有实例的集合 Session .

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.async_scoped_session.no_autoflush¶

返回禁用自动刷新的上下文管理器。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

例如。：：

with session.no_autoflush:

    some_object = SomeClass()
    session.add(some_object)
    # won't autoflush
    some_object.related_thing = session.query(SomeRelated).first()

在 with: 块不会受到查询访问时发生的刷新的影响。这在初始化涉及现有数据库查询的一系列对象时很有用，因为在这些对象中，尚未完成的对象尚未刷新。

method sqlalchemy.ext.asyncio.async_scoped_session.classmethod object_session(instance)¶

返回 Session 对象所属的。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

代表 Session 代表 AsyncSession 班级。

这是的别名 object_session() .

method sqlalchemy.ext.asyncio.async_scoped_session.refresh(instance, attribute_names=None, with_for_update=None)¶

使给定实例上的属性过期并刷新。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

将向数据库发出一个查询，所有属性都将使用其当前数据库值进行刷新。

这是的异步版本 Session.refresh() 方法。有关所有选项的完整描述，请参见该方法。

参见

Session.refresh() -更新的主要文档

async method sqlalchemy.ext.asyncio.async_scoped_session.remove()¶

处理掉当前的 AsyncSession ，如果存在。

与SCOPED_SESSION的REMOVE方法不同，此方法将使用AWAIT等待AsyncSession的Close方法。

method sqlalchemy.ext.asyncio.async_scoped_session.rollback()¶: 回滚正在进行的当前事务。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

method sqlalchemy.ext.asyncio.async_scoped_session.scalar(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 执行语句并返回标量结果。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

参见

Session.scalar() -标量的主要文档

method sqlalchemy.ext.asyncio.async_scoped_session.scalars(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶

执行语句并返回标量结果。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

返回: 一个 ScalarResult 对象

1.4.24 新版功能.

参见

Session.scalars() -标量的主要文档

AsyncSession.stream_scalars() -流媒体版本

method sqlalchemy.ext.asyncio.async_scoped_session.stream(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 代理用于 AsyncSession 类代表 async_scoped_session 班级。

执行语句并返回流 AsyncResult 对象。

method sqlalchemy.ext.asyncio.async_scoped_session.stream_scalars(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶

执行语句并返回标量结果流。

代理用于 AsyncSession 类代表 async_scoped_session 班级。

返回: 一个 AsyncScalarResult 对象

1.4.24 新版功能.

参见

Session.scalars() -标量的主要文档

AsyncSession.scalars() -非流版本

class sqlalchemy.ext.asyncio.AsyncSession(bind=None, binds=None, sync_session_class=None, **kw)¶

的异步版本 Session .

这个 AsyncSession 是传统的 Session 实例。

1.4 新版功能.

要使用 AsyncSession 带自定义 Session 实现，请参阅 AsyncSession.sync_session_class 参数。

类签名

class sqlalchemy.ext.asyncio.AsyncSession (sqlalchemy.ext.asyncio.base.ReversibleProxy)

attribute sqlalchemy.ext.asyncio.AsyncSession.sync_session_class = <class 'sqlalchemy.orm.session.Session'>¶

类或可调用类，该类或可调用类提供基础 Session 实例为特定的 AsyncSession 。

在类级别，此属性是 AsyncSession.sync_session_class 参数。的自定义子类 AsyncSession 可以覆盖此设置。

在实例级别，此属性指示用于提供 Session 此实例的 AsyncSession 实例。

1.4.24 新版功能.

method sqlalchemy.ext.asyncio.AsyncSession.__init__(bind=None, binds=None, sync_session_class=None, **kw)¶

构建新的 AsyncSession 。

除以外的所有参数 sync_session_class 传递给 sync_session_class 可直接调用以实例化新的 Session 。请参阅 Session.__init__() 有关参数文档，请参阅。

参数: sync_session_class¶ -- A Session 子类或其他可调用类，这些子类或其他可调用对象将用于构造 Session 它将被代理。此参数可用于提供自定义 Session 子类。默认设置为 AsyncSession.sync_session_class 类级属性。。。添加的版本：：1.4.24

method sqlalchemy.ext.asyncio.AsyncSession.add(instance, _warn=True)¶

将对象放置在 Session .

代表 Session 代表 AsyncSession 班级。

它的状态将在下次刷新操作时保留到数据库中。

重复呼叫 add() 将被忽略。相反的 add() 是 expunge() .

method sqlalchemy.ext.asyncio.AsyncSession.add_all(instances)¶: 将给定的实例集合添加到此 Session .

代表 Session 代表 AsyncSession 班级。

method sqlalchemy.ext.asyncio.AsyncSession.begin(**kw)¶

返回一 AsyncSessionTransaction 对象。

底层 Session 将执行“开始”操作时 AsyncSessionTransaction 输入对象：

async with async_session.begin():
    # .. ORM transaction is begun

有关ORM begin的一般描述，请参见 Session.begin() .

method sqlalchemy.ext.asyncio.AsyncSession.begin_nested(**kw)¶

返回一 AsyncSessionTransaction 对象，它将开始一个“嵌套”事务，例如SAVEPOINT。

行为与 AsyncSession.begin() .

有关ORM begin nested的一般说明，请参阅 Session.begin_nested() .

async method sqlalchemy.ext.asyncio.AsyncSession.close()¶

关闭此对象使用的事务性资源和ORM对象 AsyncSession 。

小技巧

参见

关闭 - detail on the semantics of AsyncSession.close()

method sqlalchemy.ext.asyncio.AsyncSession.async classmethod close_all()¶: 全部关闭 AsyncSession 会议。

async method sqlalchemy.ext.asyncio.AsyncSession.commit()¶: 提交当前正在进行的事务。

async method sqlalchemy.ext.asyncio.AsyncSession.connection(**kw)¶

返回A AsyncConnection 与此对应的对象 Session 对象的事务状态。

此方法还可用于为当前事务使用的数据库连接建立执行选项。

1.4.24 新版功能: 添加了**kw参数，这些参数将传递到基础 Session.connection() 方法。

参见

Session.connection() -“连接”的主要文档

async method sqlalchemy.ext.asyncio.AsyncSession.delete(instance)¶

将实例标记为已删除。

数据库删除操作发生在 flush() .

由于此操作可能需要沿着卸载的关系级联，因此允许发生这些查询是可以等待的。

参见

Session.delete() -删除的主要文档

attribute sqlalchemy.ext.asyncio.AsyncSession.deleted¶: 此中标记为“已删除”的所有实例的集合 Session

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.AsyncSession.dirty¶

所有持久实例的集合被认为是脏的。

代表 Session 代表 AsyncSession 班级。

例如。：：

some_mapped_object in session.dirty

实例在被修改但未被删除时被视为脏实例。

要检查实例是否对其属性进行了可操作的网络更改，请使用 Session.is_modified() 方法。

async method sqlalchemy.ext.asyncio.AsyncSession.execute(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 执行语句并返回缓冲区 Result 对象。

参见

Session.execute() -执行的主要文档

method sqlalchemy.ext.asyncio.AsyncSession.expire(instance, attribute_names=None)¶

使实例上的属性过期。

代表 Session 代表 AsyncSession 班级。

使中的所有对象过期 Session 同时，使用 Session.expire_all() .

参数

instance¶ -- 要刷新的实例。
attribute_names¶ -- 指示要过期的属性子集的字符串属性名称的可选列表。

参见

刷新/过期 -介绍性材料

method sqlalchemy.ext.asyncio.AsyncSession.expire_all()¶

使此会话中的所有永久实例过期。

代表 Session 代表 AsyncSession 班级。

要使这些对象上的单个对象和单个属性过期，请使用 Session.expire() .

参见

刷新/过期 -介绍性材料

“由于在刷新过程中出现以前的异常，此会话的事务已回滚。”（或类似）

method sqlalchemy.ext.asyncio.AsyncSession.expunge(instance)¶

移除 instance 由此 Session .

代表 Session 代表 AsyncSession 班级。

这将释放对该实例的所有内部引用。将根据删去级联规则。

method sqlalchemy.ext.asyncio.AsyncSession.expunge_all()¶

从此中删除所有对象实例 Session .

代表 Session 代表 AsyncSession 班级。

这相当于呼叫 expunge(obj) 在所有对象上 Session .

async method sqlalchemy.ext.asyncio.AsyncSession.flush(objects=None)¶: 将所有对象更改刷新到数据库。

参见

Session.flush() -同花顺的主要文档

async method sqlalchemy.ext.asyncio.AsyncSession.get(entity, ident, options=None, populate_existing=False, with_for_update=None, identity_token=None)¶: 根据给定的主键标识符返回实例，或者 None 如果找不到的话。

参见

Session.get() -GET的主要文档

method sqlalchemy.ext.asyncio.AsyncSession.get_bind(mapper=None, clause=None, bind=None, _sa_skip_events=None, _sa_skip_for_implicit_returning=False)¶

返回一个“绑定”，此 Session 是绑定的。

代表 Session 代表 AsyncSession 班级。

“bind”通常是 Engine ，除非 Session 已直接绑定到 Connection .

对于多重绑定或未绑定 Session , the mapper 或 clause 参数用于确定要返回的适当绑定。

注意，“mapper”参数通常在 Session.get_bind() 通过ORM操作调用，例如 Session.query() ，中的每个插入/更新/删除操作 Session.flush() ，电话等。

决议顺序为：

如果给出映射器并且 Session.binds 如果存在，则首先基于正在使用的映射器，然后基于正在使用的映射类，然后基于中存在的任何基类定位绑定 __mro__ 从更具体的超类到更一般的映射类。
如果给出条款和 Session.binds 存在，则根据 Table 在给定子句中找到的对象存在于 Session.binds .
如果 Session.binds 存在，还那个。
如果给定子句，则尝试返回链接到 MetaData 最终与该条款相关。
如果给定了映射器，则尝试返回链接到 MetaData 最终与 Table 或映射器映射到的其他可选对象。
找不到绑定， UnboundExecutionError 提高了。

请注意 Session.get_bind() 方法可以在的用户定义子类上重写 Session 提供任何类型的绑定解决方案。参见中的示例自定义垂直分区 .

参数

mapper¶ -- 可选的 mapper() 映射的类或实例 Mapper . 绑定可以从 Mapper 首先查阅与此相关联的“绑定”映射 Session 第二，通过咨询 MetaData 与 Table 其中 Mapper 为绑定映射。
clause¶ -- A ClauseElement （即 select() ， text() 等）。如果 mapper 参数不存在或无法生成绑定，将搜索给定的表达式构造以查找绑定元素，通常是 Table 与绑定关联 MetaData .

参见

分区策略（例如，每个会话有多个数据库后端）

Session.binds

Session.bind_mapper()

Session.bind_table()

method sqlalchemy.ext.asyncio.AsyncSession.get_nested_transaction()¶

返回当前正在进行的嵌套事务(如果有)。

返回: 一个 AsyncSessionTransaction 对象，或 None 。

1.4.18 新版功能.

method sqlalchemy.ext.asyncio.AsyncSession.get_transaction()¶

返回正在进行的当前根事务(如果有)。

返回: 一个 AsyncSessionTransaction 对象，或 None 。

1.4.18 新版功能.

method sqlalchemy.ext.asyncio.AsyncSession.classmethod identity_key(*args, **kwargs)¶

返回标识密钥。

代表 Session 代表 AsyncSession 班级。

这是的别名 identity_key() .

method sqlalchemy.ext.asyncio.AsyncSession.in_nested_transaction()¶: 如果出现以下情况，则返回True Session 已开始嵌套事务，例如保存点。

代表 Session 代表 AsyncSession 班级。

1.4 新版功能.

method sqlalchemy.ext.asyncio.AsyncSession.in_transaction()¶: 如果出现以下情况，则返回True Session 已经开始了一项交易。

代表 Session 代表 AsyncSession 班级。

1.4 新版功能.

参见

Session.is_active

attribute sqlalchemy.ext.asyncio.AsyncSession.info¶

用户可修改字典。

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.AsyncSession.is_active¶

如果这是真的 Session 不处于“部分回滚”状态。

代表 Session 代表 AsyncSession 班级。

在 1.4 版更改: 这个 Session 不再立即开始新事务，因此当 Session 首先实例化。

“部分回滚”状态通常表示 Session 已经失败了 Session.rollback() 方法才能完全回滚事务。

如果这样 Session 根本不在事务中 Session 第一次使用时会自动注册，所以在本例中 Session.is_active 将返回true。

否则，如果 Session 在事务中，并且该事务尚未在内部回滚，则 Session.is_active 也将返回True。

参见

Session.in_transaction()

method sqlalchemy.ext.asyncio.AsyncSession.is_modified(instance, include_collections=True)¶

返回 True 如果给定实例具有本地修改的属性。

代表 Session 代表 AsyncSession 班级。

此方法检索实例上每个已检测属性的历史记录，并将当前值与其以前提交的值（如果有）进行比较。

实际上，它是在 Session.dirty 集合；对每个属性的网络“脏”状态执行完整测试。

例如。：：

return session.is_modified(someobject)

该方法的一些注意事项适用于：

存在于中的实例 Session.dirty 集合可能报告 False 当用这种方法测试时。这是因为对象可能通过属性突变接收到更改事件，因此将其放入 Session.dirty 但最终状态与从数据库加载的状态相同，因此此处不会发生任何净更改。
在应用新值时，如果在接收到新值时属性未被加载或已过期，则标量属性可能没有记录以前设置的值-在这些情况下，假定该属性发生更改，即使其数据库值最终没有净更改。在大多数情况下，当一个集合事件发生时，sqlAlchemy不需要“old”值，因此如果旧值不存在，它会跳过SQL调用的开销，这是基于通常需要更新标量值的假设，而在少数情况下，它不存在的情况下，平均比发出防御性选择的代价要低。

只有当属性容器具有 active_history 标志设置为 True . 此标志通常为不是简单的多对一的主键属性和标量对象引用设置。要为任意映射列设置此标志，请使用 active_history 争论与 column_property() .

参数

instance¶ -- 要测试的映射实例是否存在挂起的更改。
include_collections¶ -- 指示操作中是否应包含多值集合。设置为 False 是一种只检测本地基于列的属性（即标量列或多对一外键）的方法，在刷新时将导致此实例的更新。

async method sqlalchemy.ext.asyncio.AsyncSession.merge(instance, load=True, options=None)¶: 将给定实例的状态复制到 AsyncSession .

参见

Session.merge() -合并的主要文档

attribute sqlalchemy.ext.asyncio.AsyncSession.new¶: 在此中标记为“new”的所有实例的集合 Session .

代表 Session 代表 AsyncSession 班级。

attribute sqlalchemy.ext.asyncio.AsyncSession.no_autoflush¶

返回禁用自动刷新的上下文管理器。

代表 Session 代表 AsyncSession 班级。

例如。：：

with session.no_autoflush:

    some_object = SomeClass()
    session.add(some_object)
    # won't autoflush
    some_object.related_thing = session.query(SomeRelated).first()

method sqlalchemy.ext.asyncio.AsyncSession.classmethod object_session(instance)¶

返回 Session 对象所属的。

代表 Session 代表 AsyncSession 班级。

这是的别名 object_session() .

async method sqlalchemy.ext.asyncio.AsyncSession.refresh(instance, attribute_names=None, with_for_update=None)¶

使给定实例上的属性过期并刷新。

将向数据库发出一个查询，所有属性都将使用其当前数据库值进行刷新。

这是的异步版本 Session.refresh() 方法。有关所有选项的完整描述，请参见该方法。

参见

Session.refresh() -更新的主要文档

async method sqlalchemy.ext.asyncio.AsyncSession.rollback()¶: 回滚正在进行的当前事务。

async method sqlalchemy.ext.asyncio.AsyncSession.run_sync(fn, *arg, **kw)¶

调用给定的sync callable，将sync self作为第一个参数传递。

此方法通过在一个特殊检测的greenlet中运行给定的callable来维护从到数据库连接的asyncio事件循环。

例如。：：

with AsyncSession(async_engine) as session:
    await session.run_sync(some_business_method)

注解

参见

在Asyncio下运行同步方法和函数

async method sqlalchemy.ext.asyncio.AsyncSession.scalar(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 执行语句并返回标量结果。

参见

Session.scalar() -标量的主要文档

async method sqlalchemy.ext.asyncio.AsyncSession.scalars(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶

执行语句并返回标量结果。

返回: 一个 ScalarResult 对象

1.4.24 新版功能.

参见

Session.scalars() -标量的主要文档

AsyncSession.stream_scalars() -流媒体版本

async method sqlalchemy.ext.asyncio.AsyncSession.stream(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶: 执行语句并返回流 AsyncResult 对象。

async method sqlalchemy.ext.asyncio.AsyncSession.stream_scalars(statement, params=None, execution_options={}, bind_arguments=None, **kw)¶

执行语句并返回标量结果流。

返回: 一个 AsyncScalarResult 对象

1.4.24 新版功能.

参见

Session.scalars() -标量的主要文档

AsyncSession.scalars() -非流版本

attribute sqlalchemy.ext.asyncio.AsyncSession.sync_session: sqlalchemy.orm.session.Session¶

对基础的 Session 这 AsyncSession 代理请求指向。

此实例可以用作事件目标。

参见