Есть ли разница между asyncsession.begin() и session.commit()?

Question

[oslik_ppc]

Привет! Пытаюсь разобраться с asyncIO в SQLAlchemy, и тут возник вопрос, например при создании объекта в БД, есть два варианта, подскажите в чем разница?
1. Использование commit(), и один контекст менеджер
async with async_session() as session:
result = await session.execute(select(A).where(A.id == 1))
a1 = result.scalars().one()
a1.data = "new data"
await session.commit()
2. Без commit(), но используется два вложенных менеджера:
async with async_session() as session:
async with session.begin():
session.add_all(
[
A(bs=[B(), B()], data="a1"),
A(bs=[], data="a2"),
A(bs=[B(), B()], data="a3"),
]
)
Во втором, после выхода из менеджера происходит авто-коммит, но какая разница между этими подходами?

Comments

[Модератор]

Фрагменты кода надо размещать в виде текста и оборачивать тэгом code для корректного отображения. Удобно делать кнопкой </>
Это обязательно, см.п.3.8 Регламента.
Сюда же относится traceback, ввод и вывод в консоли и другая структурированная текстовая инфа.

Answer 1

[Загир Меджидов]

В SQLAlchemy asyncIO, asyncsession.begin() и session.commit() представляют два разных этапа в асинхронном цикле работы сессии.

asyncsession.begin() используется для начала транзакции. Транзакция представляет собой блок операций, который будет выполнен атомарно – либо все операции успешно применятся, либо ни одна из них. Транзакция обеспечивает целостность данных и позволяет откатывать операции, если что-то идет не так.

session.commit() используется для фиксации (commit) изменений, сделанных во время транзакции. Это означает, что все изменения, выполненные в рамках транзакции, сохраняются в базе данных. Если транзакция завершилась успешно, то изменения становятся видимыми для других пользователей базы данных.

Таким образом, asyncsession.begin() начинает транзакцию, а session.commit() закрывает транзакцию и сохраняет изменения. Эти операции необходимо использовать совместно для правильной работы сессии.

Пример использования:

async with AsyncSession(engine) as session:
    async with session.begin():
        # выполнение операций внутри транзакции
        # изменение, добавление или удаление объектов
        # выполнение запросов

    # после окончания транзакции вызываем session.commit()
    await session.commit()

Comments

[oslik_ppc]

Но у ContextManager сессии, есть транзакции и в TransactionalContext в __exit__

def __exit__(self, type_: Any, value: Any, traceback: Any) -> None:
        subject = getattr(self, "_trans_subject", None)

        # simplistically we could assume that
        # "subject._trans_context_manager is self".  However, any calling
        # code that is manipulating __exit__ directly would break this
        # assumption.  alembic context manager
        # is an example of partial use that just calls __exit__ and
        # not __enter__ at the moment.  it's safe to assume this is being done
        # in the wild also
        out_of_band_exit = (
            subject is None or subject._trans_context_manager is not self
        )

        if type_ is None and self._transaction_is_active():
            try:
                self.commit()
...................

Получается, при выходе из контекста он пытается сделать commit(), и вроде как доп вызов - избыточен, разве нет?

[Загир Меджидов]

Скорее всего он пытается сохранить данные при неожиданном закрытии сессии. Приглядевшись к коду можно заметить, что идут разные проверки и отслеживание ошибок, думаю, что нечего в этом нету.

[oslik_ppc]

Загир Меджидов, понял, спасибо! Просто в документации как-то все расплывчато, например в исходниках begin():

def begin(self) -> _AsyncSessionContextManager[_AS]:
        """Produce a context manager that both provides a new
        :class:`_orm.AsyncSession` as well as a transaction that commits.


        e.g.::

            async def main():
                Session = async_sessionmaker(some_engine)

                async with Session.begin() as session:
                    session.add(some_object)

                # commits transaction, closes session


        """

        session = self()
        return session._maker_context_manager()

Указывается, что на выходе из менеджера происходит commit()

[Загир Меджидов]

oslik_ppc, Пожалуйста. Хотелось бы, чтобы вы отметили мой ответ как решение, чтобы не обесценить мой труд. )

[brightcow]

А разве бегин не включает в себя коммит

[oslik_ppc]

Загир Меджидов, так и сделал, мне помог Ваш ответ, но просто для ясности, можно еще подсказку по надобности commit():

Если sessionmaker() через __call__ возвращает объект AssyncSession, то он сам по себе context-manager, при выходе из него он просто закрывает сессию:

#CODE: class AsyncSession(ReversibleProxy[Session]):

    async def __aexit__(self, type_: Any, value: Any, traceback: Any) -> None:
        task = asyncio.create_task(self.close())
        await asyncio.shield(task)

Но вот его метод begin() как раз возвращает AsyncSessionTransaction (как вы и сказали, начинает транзакцию):

#CODE: class AsyncSession(ReversibleProxy[Session]):
    def begin(self) -> AsyncSessionTransaction:
        """Return an :class:`_asyncio.AsyncSessionTransaction` object.

        The underlying :class:`_orm.Session` will perform the
        "begin" action when the :class:`_asyncio.AsyncSessionTransaction`
        object is entered::

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

        Note that database IO will not normally occur when the session-level
        transaction is begun, as database transactions begin on an
        on-demand basis.  However, the begin block is async to accommodate
        for a :meth:`_orm.SessionEvents.after_transaction_create`
        event hook that may perform IO.

        For a general description of ORM begin, see
        :meth:`_orm.Session.begin`.

        """

        return AsyncSessionTransaction(self)

Но на выходе из контекста:

# CODE: class AsyncSessionTransaction
    async def __aexit__(self, type_: Any, value: Any, traceback: Any) -> None:
        await greenlet_spawn(
            self._sync_transaction().__exit__, type_, value, traceback
        )

Который как раз делает commit() (ну, старается или rollback())

def __exit__(self, type_: Any, value: Any, traceback: Any) -> None:
        subject = getattr(self, "_trans_subject", None)

        # simplistically we could assume that
        # "subject._trans_context_manager is self".  However, any calling
        # code that is manipulating __exit__ directly would break this
        # assumption.  alembic context manager
        # is an example of partial use that just calls __exit__ and
        # not __enter__ at the moment.  it's safe to assume this is being done
        # in the wild also
        out_of_band_exit = (
            subject is None or subject._trans_context_manager is not self
        )

        if type_ is None and self._transaction_is_active():
            try:
                self.commit()
            except:
                with util.safe_reraise():
                    if self._rollback_can_be_called():
                        self.rollback()
            finally:
                if not out_of_band_exit:
                    assert subject is not None
                    subject._trans_context_manager = self._outer_trans_ctx
                self._trans_subject = self._outer_trans_ctx = None