异步 I/O（异步）
支持Python异步。包括对Core和ORM使用的支持，使用了异步兼容的方言。
1.4 新版功能.
注解
从SQLAlChemy 1.4.3开始的异步扩展现在可以被认为是 测试级 软件。API细节可能会更改，但是在这一点上，不太可能有重大的向后不兼容更改。
参见
对内核和ORM的异步IO支持 -初始功能发布
异步集成 -示例脚本演示了asyncio扩展中核心和ORM使用的工作示例。
Asyncio平台安装说明
异步扩展至少需要Python 3.6版。这还取决于 greenlet 类库。默认情况下，此依赖项安装在通用计算机平台上，包括：
x86_64 aarch64 ppc64le amd64 win32
对于上述平台， greenlet 为人所知的是提供预置的轮子文件。为了确保 greenlet 依赖项存在于其他平台上，则 [asyncio] 可以按如下方式安装Extra，其中将包括尝试构建和安装 greenlet ：：
pip install sqlalchemy[asyncio]
概要-核心
对于核心用途 create_async_engine() 函数创建 AsyncEngine 它提供了传统 Engine 应用程序编程接口。这个 AsyncEngine 提供 AsyncConnection 通过其 AsyncEngine.connect() 和 AsyncEngine.begin() 方法都提供异步上下文管理器。这个 AsyncConnection 然后可以使用 AsyncConnection.execute() 方法传递缓冲区 Result ，或者 AsyncConnection.stream() 方法传递流式服务器端 AsyncResult ：：
import asyncio
from sqlalchemy.ext.asyncio import create_async_engine
async def async_main():
engine = create_async_engine(
"postgresql+asyncpg://scott:tiger@localhost/test", echo=True,
)
async with engine.begin() as conn:
await conn.run_sync(meta.drop_all)
await conn.run_sync(meta.create_all)
await conn.execute(
t1.insert(), [{"name": "some name 1"}, {"name": "some name 2"}]
)
async with engine.connect() as conn:
# select a Result, which will be delivered with buffered
# results
result = await conn.execute(select(t1).where(t1.c.name == "some name 1"))
print(result.fetchall())
# for AsyncEngine created in function scope, close and
# clean-up pooled connections
await engine.dispose()
asyncio.run(async_main())上面， AsyncConnection.run_sync() 方法可用于调用特殊的DDL函数，例如 MetaData.create_all() 那不包括一个等待的钩子。
小技巧
建议您调用 AsyncEngine.dispose() 方法使用 await 在使用 AsyncEngine 对象，该对象将脱离上下文并被垃圾回收，如 async_main 函数。这确保由连接池保持打开的任何连接将被正确地放置在可等待的上下文中。与使用阻塞IO时不同，SQLAlChemy不能在如下方法中正确处理这些连接 __del__ 或弱ref终结器，因为没有机会调用 await 。当引擎落入范围之外时，如果不显式处置引擎，可能会导致向标准输出发出类似于该表单的警告 RuntimeError: Event loop is closed 在垃圾收集中。
这个 AsyncConnection 还具有通过 AsyncConnection.stream() 方法返回 AsyncResult 对象。此结果对象使用服务器端游标并提供异步/等待API，例如异步迭代器：
async with engine.connect() as conn:
async_result = await conn.stream(select(t1))
async for row in async_result:
print("row: %s" % (row, ))概要-ORM
使用 2.0 style 查询时， AsyncSession 类提供完整的ORM功能。在默认使用模式下，必须特别注意避免 lazy loading 或其他涉及ORM关系和列属性的过期属性访问；下一节 使用AsyncSession时防止隐式IO 详细说明了这一点。下面的示例说明了一个完整的示例，包括映射器和会话配置：
import asyncio
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import ForeignKey
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.future import select
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy.orm import selectinload
from sqlalchemy.orm import sessionmaker
Base = declarative_base()
class A(Base):
__tablename__ = "a"
id = Column(Integer, primary_key=True)
data = Column(String)
create_date = Column(DateTime, server_default=func.now())
bs = relationship("B")
# required in order to access columns with server defaults
# or SQL expression defaults, subsequent to a flush, without
# triggering an expired load
__mapper_args__ = {"eager_defaults": True}
class B(Base):
__tablename__ = "b"
id = Column(Integer, primary_key=True)
a_id = Column(ForeignKey("a.id"))
data = Column(String)
async def async_main():
engine = create_async_engine(
"postgresql+asyncpg://scott:tiger@localhost/test",
echo=True,
)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.drop_all)
await conn.run_sync(Base.metadata.create_all)
# expire_on_commit=False will prevent attributes from being expired
# after commit.
async_session = sessionmaker(
engine, expire_on_commit=False, class_=AsyncSession
)
async with async_session() as session:
async with session.begin():
session.add_all(
[
A(bs=[B(), B()], data="a1"),
A(bs=[B()], data="a2"),
A(bs=[B(), B()], data="a3"),
]
)
stmt = select(A).options(selectinload(A.bs))
result = await session.execute(stmt)
for a1 in result.scalars():
print(a1)
print(f"created at: {a1.create_date}")
for b1 in a1.bs:
print(b1)
result = await session.execute(select(A).order_by(A.id))
a1 = result.scalars().first()
a1.data = "new data"
await session.commit()
# access attribute subsequent to commit; this is what
# expire_on_commit=False allows
print(a1.data)
# for AsyncEngine created in function scope, close and
# clean-up pooled connections
await engine.dispose()
asyncio.run(async_main())在上面的示例中， AsyncSession 使用可选的 sessionmaker 帮助器，并与 AsyncEngine 针对特定的数据库URL。然后在Python异步上下文管理器中使用它(即 async with: 语句)，以便它在挡路结束时自动关闭；这等效于调用 AsyncSession.close() 方法。
注解
AsyncSession 使用SQLAlChemy的未来模式，该模式有几个潜在的突破性更改。其中一个更改是新的默认行为 cascade_backrefs 是 False ，这可能会影响将相关对象保存到数据库的方式。
参见
使用AsyncSession时防止隐式IO
使用传统的异步方式，应用程序需要避免可能发生按属性访问IO的任何点。在上述情况下，我们采取了以下措施来防止这种情况的发生：
这个
selectinload()紧急装载机的使用是为了紧急装载A.bs对象范围内的集合await session.execute()电话：：stmt = select(A).options(selectinload(A.bs))
如果“lazyload”的默认加载程序策略保持不变，则
A.bs属性将引发异步CIO异常。有多种ORM加载器选项可用，这些选项可以在默认映射级别配置，也可以在每个查询的基础上使用，文档为 关系加载技术 。这个
AsyncSession是使用以下方式配置的Session.expire_on_commit设置为false，以便我们可以在调用AsyncSession.commit()，如我们访问属性：：的末尾那行所示# create AsyncSession with expire_on_commit=False async_session = AsyncSession(engine, expire_on_commit=False) # sessionmaker version async_session = sessionmaker( engine, expire_on_commit=False, class_=AsyncSession ) async with async_session() as session: result = await session.execute(select(A).order_by(A.id)) a1 = result.scalars().first() # commit would normally expire all attributes await session.commit() # access attribute subsequent to commit; this is what # expire_on_commit=False allows print(a1.data)这个
Column.server_default上的值。created_at默认情况下，插入后不会刷新列；相反，它通常是 expired so that it can be loaded when needed 。类似的行为也适用于列，其中Column.default参数分配给SQL表达式对象。若要使用asyncio访问此值，必须在刷新过程中刷新该值，这可以通过设置mapper.eager_defaults映射上的参数：：class A(Base): # ... # column with a server_default, or SQL expression default create_date = Column(DateTime, server_default=func.now()) # add this so that it can be accessed __mapper_args__ = {"eager_defaults": True}
其他准则包括：
像这样的方法
AsyncSession.expire()应该避免，而是有利于AsyncSession.refresh()避免使用
all层叠选项记录在 级联 支持明确列出所需的级联功能。这个all级联选项除其他选项外，还暗示 刷新期满 设置，这意味着AsyncSession.refresh()方法将使相关对象的属性过期，但不一定刷新这些相关对象(假设没有在relationship()，使其处于过期状态。将来的版本可能会引入在调用时指示急切加载程序选项的功能Session.refresh()和/或AsyncSession.refresh()。应采用适当的装载机选项
deferred()列(如果使用的话)，以及relationship()构造如上所述。看见 延迟列加载 有关延迟列加载的背景信息，请参阅。
中描述的“动态”关系加载器策略 动态关系加载器 默认情况下与异步方法不兼容。方法中调用时，才能直接使用它。
AsyncSession.run_sync()有关方法的说明，请参阅 在Asyncio下运行同步方法和函数 ，或使用其.statement属性以获取普通选择：：user = await session.get(User, 42) addresses = (await session.scalars(user.addresses.statement)).all() stmt = user.addresses.statement.where( Address.email_address.startswith("patrick") ) addresses_filter = (await session.scalars(stmt)).all()
在Asyncio下运行同步方法和函数
Deep Alchemy
这种方法实质上公开了SQLAlchemy首先能够提供asyncio接口的机制。虽然这样做没有技术问题，但总体而言，这种方法可能会被认为是“有争议的”，因为它违背了asyncio编程模型的一些中心思想，即任何可能导致IO被调用的编程语句 must 有一个 await 调用，以免程序没有显式地清除IO可能发生的每一行。这种方法并没有改变这种一般的想法，只是它允许一系列同步IO指令在一个函数调用的范围内不受此规则的约束，基本上被捆绑成一个单独的等待指令。
作为在异步事件循环中集成传统SQLAlchemy“延迟加载”的替代方法，一个 可选择的 方法称为 AsyncSession.run_sync() 它将在greenlet内部运行任何Python函数，传统的同步编程概念将被转换为使用 await 当它们到达数据库驱动程序时。这里的一个假设方法是一个面向异步的应用程序，它可以将与数据库相关的方法打包成使用调用的函数 AsyncSession.run_sync() .
如果我们不使用 selectinload() 对于 A.bs 集合中，我们可以在单独的函数中完成对这些属性访问的处理：
import asyncio
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.ext.asyncio import AsyncSession
def fetch_and_update_objects(session):
"""run traditional sync-style ORM code in a function that will be
invoked within an awaitable.
"""
# the session object here is a traditional ORM Session.
# all features are available here including legacy Query use.
stmt = select(A)
result = session.execute(stmt)
for a1 in result.scalars():
print(a1)
# lazy loads
for b1 in a1.bs:
print(b1)
# legacy Query use
a1 = session.query(A).order_by(A.id).first()
a1.data = "new data"
async def async_main():
engine = create_async_engine(
"postgresql+asyncpg://scott:tiger@localhost/test", echo=True,
)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.drop_all)
await conn.run_sync(Base.metadata.create_all)
async with AsyncSession(engine) as session:
async with session.begin():
session.add_all(
[
A(bs=[B(), B()], data="a1"),
A(bs=[B()], data="a2"),
A(bs=[B(), B()], data="a3"),
]
)
await session.run_sync(fetch_and_update_objects)
await session.commit()
# for AsyncEngine created in function scope, close and
# clean-up pooled connections
await engine.dispose()
asyncio.run(async_main())上述在“sync”运行器中运行某些函数的方法与在基于事件的编程库（如 gevent . 区别如下：
与使用时不同
gevent，我们可以继续使用标准Python异步事件循环或任何自定义事件循环，而无需集成到gevent事件循环。根本不存在“恶作剧”。上面的例子使用了一个真正的异步驱动程序，底层的SQLAlchemy连接池也使用了Python内置的
asyncio.Queue用于池连接。该程序可以在异步/等待代码和包含的使用同步代码的函数之间自由切换，几乎没有性能损失。没有“线程执行器”或任何其他等待器或同步正在使用。
底层网络驱动程序也使用纯Python异步概念，没有第三方网络库
gevent和eventlet提供正在使用中。
使用带有异步扩展名的事件
SQL炼金术 event system 不是由异步扩展直接公开的，这意味着还没有“异步”版本的SQLAlChemy事件处理程序。
然而，由于异步扩展围绕着通常的同步SQLAlChemy API，常规的“同步”样式的事件处理程序是免费可用的，就像不使用异步时一样。
如下所述，当前有两种策略来注册给定的异步面向异步API的事件：
可以在实例级别注册事件(例如，特定的
AsyncEngine实例)，方法是将事件与sync引用代理对象的属性。例如，要注册PoolEvents.connect()事件针对AsyncEngine实例，请使用其AsyncEngine.sync_engine属性作为目标。目标包括：在类级别注册事件，以同一类型的所有实例为目标(例如All
AsyncSession实例)，则使用相应的同步样式类。例如，要注册SessionEvents.before_commit()事件针对AsyncSession类，请使用Session类作为目标。
当在异步上下文中的事件处理程序中工作时， Connection 继续以通常的“同步”方式工作，而不需要 await 或 async 当异步数据库适配器最终接收到消息时，调用风格被透明地调整回异步调用风格。对于传递DBAPI级别连接的事件，例如 PoolEvents.connect() ，则该对象是一个 pep-249 兼容的“连接”对象，它将使同步风格的调用适应于异步驱动程序。
与面向异步的API构造相关联的同步样式事件处理程序的一些示例如下所示：
import asyncio
from sqlalchemy import text
from sqlalchemy.engine import Engine
from sqlalchemy import event
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.orm import Session
## Core events ##
engine = create_async_engine(
"postgresql+asyncpg://scott:tiger@localhost:5432/test"
)
# connect event on instance of Engine
@event.listens_for(engine.sync_engine, "connect")
def my_on_connect(dbapi_con, connection_record):
print("New DBAPI connection:", dbapi_con)
cursor = dbapi_con.cursor()
# sync style API use for adapted DBAPI connection / cursor
cursor.execute("select 'execute from event'")
print(cursor.fetchone()[0])
# before_execute event on all Engine instances
@event.listens_for(Engine, "before_execute")
def my_before_execute(
conn, clauseelement, multiparams, params, execution_options
):
print("before execute!")
## ORM events ##
session = AsyncSession(engine)
# before_commit event on instance of Session
@event.listens_for(session.sync_session, "before_commit")
def my_before_commit(session):
print("before commit!")
# sync style API use on Session
connection = session.connection()
# sync style API use on Connection
result = connection.execute(text("select 'execute from event'"))
print(result.first())
# after_commit event on all Session instances
@event.listens_for(Session, "after_commit")
def my_after_commit(session):
print("after commit!")
async def go():
await session.execute(text("select 1"))
await session.commit()
await session.close()
await engine.dispose()
asyncio.run(go())上面的示例打印如下行的内容：：
New DBAPI connection: <AdaptedConnection <asyncpg.connection.Connection ...>> execute from event before execute! before commit! execute from event after commit!
异步与事件，两个对立面
SQLAlChemy事件本质上是在 室内 特定SQLAlChemy进程的；也就是说，事件总是发生 之后 终端用户代码已经调用了一些特定的SQLAlChemy API，并且 在此之前 API其他一些内部方面也会发生。
将其与Asyncio扩展的体系结构进行对比，后者发生在 外部 SQLAlChemy通常从终端用户API到DBAPI函数的流程。
消息传递流可以可视化如下：
SQLAlchemy SQLAlchemy SQLAlchemy SQLAlchemy plain
asyncio asyncio ORM/Core asyncio asyncio
(public (internal) (internal)
facing)
-------------|------------|------------------------|-----------|------------
asyncio API | | | |
call -> | | | |
| -> -> | | -> -> |
|~~~~~~~~~~~~| sync API call -> |~~~~~~~~~~~|
| asyncio | event hooks -> | sync |
| to | invoke action -> | to |
| sync | event hooks -> | asyncio |
| (greenlet) | dialect -> | (leave |
|~~~~~~~~~~~~| event hooks -> | greenlet) |
| -> -> | sync adapted |~~~~~~~~~~~|
| | DBAPI -> | -> -> | asyncio
| | | | driver -> database其中，在结果以相反方向通过同一链传播之前，API调用始终以异步方式开始，流经同步API，并以异步方式结束。在这两者之间，消息首先被改编成同步样式的API使用，然后再改回异步样式。然后，事件挂钩本质上发生在“同步式API使用”的中间。由此可以得出，在事件挂钩内呈现的API发生在异步API请求已被调整为同步的进程内，并且到数据库API的输出消息将被透明地转换为异步。
使用多个异步事件循环
使用多个事件循环的应用程序(例如，通过将异步与多线程相结合)不应共享相同的事件循环 AsyncEngine 在使用默认池实现时使用不同的事件循环。
如果一个 AsyncEngine 从一个事件循环传递到另一个事件循环，则该方法 AsyncEngine.dispose() 在新的事件循环中重新使用它之前应该调用。如果不这样做，可能会导致 RuntimeError 沿着……的路线 Task <Task pending ...> got Future attached to a different loop
如果必须在不同循环之间共享同一引擎，则应将其配置为使用 NullPool ，防止引擎多次使用任何连接：：
from sqlalchemy.pool import NullPool
engine = create_async_engine(
"postgresql+asyncpg://user:pass@host/dbname", poolclass=NullPool
)使用异步作用域会话
的用法 async_scoped_session 在很大程度上类似于 scoped_session 。但是，由于异步CIO上下文中没有“线程本地”概念，因此必须向构造函数提供“scope efunc”参数：：
from asyncio import current_task from sqlalchemy.orm import sessionmaker from sqlalchemy.ext.asyncio import async_scoped_session from sqlalchemy.ext.asyncio import AsyncSession async_session_factory = sessionmaker(some_async_engine, class_=_AsyncSession) AsyncSession = async_scoped_session(async_session_factory, scopefunc=current_task) some_async_session = AsyncSession()
async_scoped_session 还包括 代理行为 与……相似 scoped_session ，这意味着它可以被视为 AsyncSession 直接，记住通常的 await 关键字是必需的，包括 async_scoped_session.remove() 方法：
async def some_function(some_async_session, some_object): # use the AsyncSession directly some_async_session.add(some_object) # use the AsyncSession via the context-local proxy await AsyncSession.commit() # "remove" the current proxied AsyncSession for the local context await AsyncSession.remove()
1.4.19 新版功能.
使用检查器检查架构对象
SQLAlChemy还没有提供异步版本的 Inspector (在以下位置介绍 带检查员的细颗粒反射 )，但是现有接口可以通过利用 AsyncConnection.run_sync() 一种方法 AsyncConnection ：：
import asyncio
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import inspect
engine = create_async_engine(
"postgresql+asyncpg://scott:tiger@localhost/test"
)
def use_inspector(conn):
inspector = inspect(conn)
# use the inspector
print(inspector.get_view_names())
# return any value to the caller
return inspector.get_table_names()
async def async_main():
async with engine.connect() as conn:
tables = await conn.run_sync(use_inspector)
asyncio.run(async_main())参见
发动机API文档
| Object Name | Description |
|---|---|
的异步代理 | |
的异步代理 | |
的异步代理 | |
create_async_engine(*arg, **kw) | 创建新的异步引擎实例。 |
- function sqlalchemy.ext.asyncio.create_async_engine(*arg, **kw)
这个
AsyncResult对象是Result对象。只有在使用AsyncConnection.stream()或AsyncSession.stream()方法，返回位于活动数据库游标顶部的结果对象。Object Name Description 包装纸
AsyncResult返回字典值而不是Row价值观。一个异步包装器
Result对象。包装纸
AsyncResult返回标量值而不是Row价值观。 - class sqlalchemy.ext.asyncio.AsyncResult(real_result)
Object Name Description async_object_session(instance)
返回
AsyncSession给定实例所属的。提供范围内的管理
AsyncSession对象。async_session(session)
返回
AsyncSession它代理给定的Session对象(如果有)。的异步版本
Session.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对象(如果有)。- 参数
- 返回
一个
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 ofScopedSessionMixin返回当前
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 ofScopedSessionMixin重新配置
sessionmaker由此使用scoped_session。
- 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语句的特定情况下才有意义。参见
刷新/过期 -介绍性材料
- 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, themapper或clause参数用于确定要返回的适当绑定。注意，“mapper”参数通常在
Session.get_bind()通过ORM操作调用，例如Session.query()，中的每个插入/更新/删除操作Session.flush()，电话等。决议顺序为：
如果给出映射器并且
Session.binds如果存在，则首先基于正在使用的映射器，然后基于正在使用的映射类，然后基于中存在的任何基类定位绑定__mro__从更具体的超类到更一般的映射类。如果给出条款和
Session.binds存在，则根据Table在给定子句中找到的对象存在于Session.binds.如果
Session.binds存在，还那个。如果给定子句，则尝试返回链接到
MetaData最终与该条款相关。找不到绑定，
UnboundExecutionError提高了。
请注意
Session.get_bind()方法可以在的用户定义子类上重写Session提供任何类型的绑定解决方案。参见中的示例 自定义垂直分区 .- 参数
参见
- 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。参见
- 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().
- 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()-标量的主要文档
- 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()-非流版本
- method
- 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请注意，数据库IO通常不会在会话级事务开始时发生，因为数据库事务是按需开始的。但是，begin块是异步的，以适应
SessionEvents.after_transaction_create()可能执行IO的事件钩子。有关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。这将删除与此关联的所有ORM对象
AsyncSession，结束正在进行的任何事务，并 releases 任何AsyncConnection此对象AsyncSession本身已从关联的AsyncEngine对象。然后，该操作将AsyncSession处于可以再次使用的状态。小技巧
这个
AsyncSession.close()方法 不会阻止再次使用该会话 。这个AsyncSession本身实际上并不具有明显的“关闭”状态；它只是表示AsyncSession将释放所有数据库连接和ORM对象。参见
关闭 - 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
实例在被修改但未被删除时被视为脏实例。
请注意，此“脏”计算是“乐观的”；大多数属性设置或集合修改操作都会将实例标记为“脏”并将其放置在此集合中，即使属性值没有净更改。在刷新时，将每个属性的值与以前保存的值进行比较，如果没有净更改，则不会发生SQL操作（这是一个更昂贵的操作，因此只在刷新时进行）。
要检查实例是否对其属性进行了可操作的网络更改，请使用
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同时，使用Session.expire_all().这个
Session对象的默认行为是在Session.rollback()或Session.commit()方法，以便可以为新事务加载新状态。为此，请致电Session.expire()只有在当前事务中发出非ORM SQL语句的特定情况下才有意义。参见
刷新/过期 -介绍性材料
- method
sqlalchemy.ext.asyncio.AsyncSession.expire_all()¶ 使此会话中的所有永久实例过期。
代表
Session代表AsyncSession班级。下次访问持久实例上的任何属性时，将使用
Session对象的当前事务上下文，以便加载给定实例的所有过期属性。请注意，高度隔离的事务将返回与以前在同一事务中读取的值相同的值，而不考虑该事务外数据库状态的更改。要使这些对象上的单个对象和单个属性过期，请使用
Session.expire().这个
Session对象的默认行为是在Session.rollback()或Session.commit()方法，以便可以为新事务加载新状态。为此，请致电Session.expire_all()当自动提交为False，假设事务是独立的。参见
刷新/过期 -介绍性材料
- 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, themapper或clause参数用于确定要返回的适当绑定。注意，“mapper”参数通常在
Session.get_bind()通过ORM操作调用，例如Session.query()，中的每个插入/更新/删除操作Session.flush()，电话等。决议顺序为：
如果给出映射器并且
Session.binds如果存在，则首先基于正在使用的映射器，然后基于正在使用的映射类，然后基于中存在的任何基类定位绑定__mro__从更具体的超类到更一般的映射类。如果给出条款和
Session.binds存在，则根据Table在给定子句中找到的对象存在于Session.binds.如果
Session.binds存在，还那个。如果给定子句，则尝试返回链接到
MetaData最终与该条款相关。找不到绑定，
UnboundExecutionError提高了。
请注意
Session.get_bind()方法可以在的用户定义子类上重写Session提供任何类型的绑定解决方案。参见中的示例 自定义垂直分区 .- 参数
参见
- 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 新版功能.
参见
- attribute
sqlalchemy.ext.asyncio.AsyncSession.info¶ 用户可修改字典。
代表
Session代表AsyncSession班级。此字典的初始值可以使用
info论据Session构造函数或sessionmaker构造函数或工厂方法。这里的字典总是本地的Session并且可以独立于所有其他Session物体。
- 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。参见
- 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().
- 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()在
with:块不会受到查询访问时发生的刷新的影响。这在初始化涉及现有数据库查询的一系列对象时很有用，因为在这些对象中，尚未完成的对象尚未刷新。
- 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)注解
提供的Callable在异步事件循环内内联调用，并将在传统IO调用上挡路。此可调用对象中的IO应该只调用SQLAlChemy的异步数据库API，这些API将适当地适应greenlet上下文。
参见
- 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()-标量的主要文档
- 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代理请求指向。此实例可以用作事件目标。
参见
- attribute
- class sqlalchemy.ext.asyncio.AsyncSessionTransaction(session, nested=False)¶
ORM的包装
SessionTransaction对象。提供此对象，以便为
AsyncSession.begin()可能会被退回。对象支持对的两个显式调用
AsyncSessionTransaction.commit()和AsyncSessionTransaction.rollback()，以及用作异步上下文管理器。1.4 新版功能.
类签名
class
sqlalchemy.ext.asyncio.AsyncSessionTransaction(sqlalchemy.ext.asyncio.base.ReversibleProxy,sqlalchemy.ext.asyncio.base.StartableContext)- async method
sqlalchemy.ext.asyncio.AsyncSessionTransaction.commit()¶ 提交此
AsyncTransaction.
- async method
sqlalchemy.ext.asyncio.AsyncSessionTransaction.rollback()¶ 回滚这个
AsyncTransaction.
- async method